From 5debf81eee05ccec1c56ffcd4dbff1a11e0407b6 Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 20 Jun 2024 20:46:32 +0200 Subject: [PATCH 01/25] gateway upgradable contract --- contracts/prototypes/ERC20CustodyNew.sol | 6 +- contracts/prototypes/Gateway.sol | 23 +- contracts/prototypes/interfaces.sol | 11 + hardhat.config.ts | 1 + package.json | 2 + test/prototypes/GatewayIntegration.spec.ts | 7 +- test/prototypes/GatewayUniswap.spec.ts | 7 +- .../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 +++++++ typechain-types/contracts/prototypes/index.ts | 2 + .../prototypes/interfaces.sol/IGateway.ts | 126 ++++ .../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 +- .../contracts/prototypes/Gateway__factory.ts | 170 ++++- .../factories/contracts/prototypes/index.ts | 1 + .../interfaces.sol/IGateway__factory.ts | 60 ++ .../prototypes/interfaces.sol/index.ts | 4 + typechain-types/hardhat.d.ts | 81 ++ typechain-types/index.ts | 18 + yarn.lock | 703 +++++++++++++++++- 55 files changed, 3099 insertions(+), 36 deletions(-) create mode 100644 contracts/prototypes/interfaces.sol 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/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/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/interfaces.sol b/contracts/prototypes/interfaces.sol new file mode 100644 index 00000000..19d2da4d --- /dev/null +++ b/contracts/prototypes/interfaces.sol @@ -0,0 +1,11 @@ +// 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); +} \ No newline at end of file diff --git a/hardhat.config.ts b/hardhat.config.ts index 36929410..4f03ded0 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -9,6 +9,7 @@ import "./tasks/addresses"; import { getHardhatConfigNetworks } from "@zetachain/networks"; import * as dotenv from "dotenv"; import type { HardhatUserConfig } from "hardhat/types"; +import "@openzeppelin/hardhat-upgrades"; dotenv.config(); diff --git a/package.json b/package.json index 34f14f00..3c93e099 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/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index ace6bb30..3bf56398 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, [], { + kind: 'uups', + initializer: 'initialize', + })) custody = await Custody.deploy(gateway.address); gateway.setCustody(custody.address); diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayUniswap.spec.ts index 42268dc7..c00fc948 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, [], { + kind: 'uups', + initializer: 'initialize', + })) as Gateway; custody = (await ERC20CustodyNew.deploy(gateway.address)) as ERC20CustodyNew; // Transfer some tokens to the custody contract 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/index.ts b/typechain-types/contracts/prototypes/index.ts index 420d0e89..f240a5c2 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -1,6 +1,8 @@ /* 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 { Receiver } from "./Receiver"; 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..1711052d --- /dev/null +++ b/typechain-types/contracts/prototypes/interfaces.sol/IGateway.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 IGatewayInterface extends utils.Interface { + functions: { + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + }; + + getFunction(nameOrSignatureOrTopic: "executeWithERC20"): FunctionFragment; + + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + 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: { + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + 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..f6896654 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/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..4fef6298 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -1,6 +1,7 @@ /* 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 { Receiver__factory } from "./Receiver__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..04761f64 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts @@ -0,0 +1,60 @@ +/* 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: "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..197e5be6 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,10 @@ declare module "hardhat/types/runtime" { name: "Gateway", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "IGateway", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "Receiver", signerOrOptions?: ethers.Signer | FactoryOptions @@ -385,6 +421,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 +831,11 @@ declare module "hardhat/types/runtime" { 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..35dbdadc 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,8 @@ 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 { 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 9cacd76e..8577519b 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.yarnpkg.com/@babel/code-frame/-/code-frame-7.21.4.tgz#d0fa9e4413aca81f2b23b9442797bda1826edb39" @@ -1443,10 +1476,10 @@ resolved "https://registry.yarnpkg.com/@nomicfoundation/hardhat-toolbox/-/hardhat-toolbox-2.0.2.tgz#ec95f23b53cb4e71a1a7091380fa223aad18f156" integrity sha512-vnN1AzxbvpSx9pfdRHbUzTRIXpMLPXnUlkW855VaDk6N1pwRaQ2gNzEmFAABk4lWf11E00PKwFd/q27HuwYrYg== -"@nomicfoundation/hardhat-verify@2.0.3": - version "2.0.3" - resolved "https://registry.yarnpkg.com/@nomicfoundation/hardhat-verify/-/hardhat-verify-2.0.3.tgz#173557f8cfa53c8c9da23a326f54d24fe459ae68" - integrity sha512-ESbRu9by53wu6VvgwtMtm108RSmuNsVqXtzg061D+/4R7jaWh/Wl/8ve+p6SdDX7vA1Z3L02hDO1Q3BY4luLXQ== +"@nomicfoundation/hardhat-verify@^2.0.3": + version "2.0.8" + resolved "https://registry.yarnpkg.com/@nomicfoundation/hardhat-verify/-/hardhat-verify-2.0.8.tgz#6a77dc03de990a1a3aa8e6dc073c393263dbf258" + integrity sha512-x/OYya7A2Kcz+3W/J78dyDHxr0ezU23DKTrRKfy5wDPCnePqnr79vm8EXqX3gYps6IjPBYyGPZ9K6E5BnrWx5Q== dependencies: "@ethersproject/abi" "^5.1.2" "@ethersproject/address" "^5.0.2" @@ -1534,6 +1567,11 @@ resolved "https://registry.yarnpkg.com/@nomiclabs/hardhat-waffle/-/hardhat-waffle-2.0.5.tgz#97c217f1db795395c04404291937edb528f3f218" 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.yarnpkg.com/@openzeppelin/contracts/-/contracts-3.4.2-solc-0.7.tgz#38f4dbab672631034076ccdf2f3201fab1726635" @@ -1549,6 +1587,54 @@ resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.8.3.tgz#cbef3146bfc570849405f59cba18235da95a252a" 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" + "@resolver-engine/core@^0.3.3": version "0.3.3" resolved "https://registry.yarnpkg.com/@resolver-engine/core/-/core-0.3.3.tgz#590f77d85d45bc7ecc4e06c654f41345db6ca967" @@ -1676,6 +1762,13 @@ "@sentry/types" "5.30.0" tslib "^1.9.3" +"@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.yarnpkg.com/@solidity-parser/parser/-/parser-0.14.5.tgz#87bc3cc7b068e08195c219c91cd8ddff5ef1a804" @@ -2223,14 +2316,25 @@ ajv@^6.10.0, ajv@^6.12.3, ajv@^6.12.4: uri-js "^4.2.2" ajv@^8.0.1: - version "8.12.0" - resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.12.0.tgz#d1a0527323e22f53562c567c00991577dfbe19d1" - integrity sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA== + version "8.16.0" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.16.0.tgz#22e2a92b94f005f7e0f9c9d39652ef0b8f6f0cb4" + integrity sha512-F0twR8U1ZU67JIEtekUcLkXkoO5mMMmgGD8sK/xUFzJ805jxHQl92hImFAqqXMyMYjSPOyUPAwHYhB72g5sTXw== dependencies: - fast-deep-equal "^3.1.1" + fast-deep-equal "^3.1.3" json-schema-traverse "^1.0.0" require-from-string "^2.0.2" - uri-js "^4.2.2" + uri-js "^4.4.1" + +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" @@ -2366,6 +2470,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.yarnpkg.com/array-includes/-/array-includes-3.1.6.tgz#9e9e720e194f198266ba9e18c29e6a9b0e4b225f" @@ -2397,6 +2509,18 @@ array-unique@^0.3.2: resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428" 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.yarnpkg.com/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz#ffc6576a7ca3efc2f46a143b9d1dda9b4b3cf5e2" @@ -2428,6 +2552,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.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d" @@ -2477,6 +2615,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.yarnpkg.com/async/-/async-1.5.2.tgz#ec6a61ae56480c0c3cb241c95618e20892f9672a" @@ -2509,6 +2654,13 @@ available-typed-arrays@^1.0.5: resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz#92f95616501069d07d10edb2fc37d3e1c65123b7" 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.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8" @@ -2519,6 +2671,22 @@ aws4@^1.8.0: resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.12.0.tgz#ce1c9d143389679e253b314241ea9aa5cec980d3" 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.yarnpkg.com/axios/-/axios-1.6.5.tgz#2c090da14aeeab3770ad30c3a1461bc970fb0cd8" @@ -2548,7 +2716,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.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== @@ -2782,6 +2950,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.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0" @@ -2840,6 +3017,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.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" @@ -2896,6 +3084,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.yarnpkg.com/chai-as-promised/-/chai-as-promised-7.1.1.tgz#08645d825deb8696ee61725dbf590c012eb00ca0" @@ -3192,6 +3387,11 @@ commander@^8.1.0: resolved "https://registry.yarnpkg.com/commander/-/commander-8.3.0.tgz#4837ea1b2da67b9c616a67afbb0fafee567bca66" 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.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0" @@ -3347,6 +3547,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.yarnpkg.com/death/-/death-1.1.0.tgz#01aa9c401edd92750514470b8266390c66c67318" @@ -3440,6 +3667,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.yarnpkg.com/define-properties/-/define-properties-1.2.0.tgz#52988570670c9eacedd8064f4a990f2405849bd5" @@ -3448,6 +3684,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.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116" @@ -3704,11 +3949,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.yarnpkg.com/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz#873f3e84418de4ee19c5be752990b2e44718d09e" 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.yarnpkg.com/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz#338d502f6f674301d710b80c8592de8a15f09cd8" @@ -3718,6 +4034,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.yarnpkg.com/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz#702e632193201e3edf8713635d083d378e510241" @@ -3725,6 +4050,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.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a" @@ -4124,7 +4456,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.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz#9ecf04861e4fbbeed7465ece5f23317ad1129181" integrity sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg== @@ -4356,6 +4688,11 @@ extsprintf@^1.2.0: resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.1.tgz#8d172c064867f235c0c84a596806d279bf4bcc07" 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.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" @@ -4526,6 +4863,11 @@ follow-redirects@^1.12.1: resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.2.tgz#b460864144ba63f2681096f274c4e57026da2c13" 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.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.4.tgz#cdc7d308bf6493126b17ea2191ea0ccf3e535adf" @@ -4680,6 +5022,11 @@ function-bind@^1.1.1: resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d" 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.yarnpkg.com/function.prototype.name/-/function.prototype.name-1.1.5.tgz#cce0505fe1ffb80503e6f9e46cc64e46a12a9621" @@ -4690,12 +5037,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.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327" 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.yarnpkg.com/functions-have-names/-/functions-have-names-1.2.3.tgz#0404fe4ee2ba2f607f0e0ec3c80bae994133b834" integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ== @@ -4736,6 +5093,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.yarnpkg.com/get-port/-/get-port-3.2.0.tgz#dd7ce7de187c06c8bf353796ac71e099f0980ebc" @@ -4749,6 +5117,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.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28" @@ -4938,7 +5315,7 @@ gopd@^1.0.1: dependencies: get-intrinsic "^1.1.3" -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.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3" integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== @@ -5083,11 +5460,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.yarnpkg.com/has-proto/-/has-proto-1.0.1.tgz#1885c1305538958aff469fef37937c22795408e0" 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.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8" @@ -5100,6 +5489,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.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f" @@ -5163,6 +5559,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.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f" @@ -5251,7 +5654,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.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352" integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== @@ -5347,6 +5750,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.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e" @@ -5382,6 +5794,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.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d" @@ -5466,6 +5886,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.yarnpkg.com/is-date-object/-/is-date-object-1.0.5.tgz#0841d5536e724c25597bf6ea62e1bd38298df31f" @@ -5564,6 +5991,11 @@ is-negative-zero@^2.0.2: resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.2.tgz#7bf6f03a28003b8b3965de3ac26f664d765f3150" 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.yarnpkg.com/is-number-object/-/is-number-object-1.0.7.tgz#59d50ada4c45251784e9904f5246c742f07a42fc" @@ -5652,6 +6084,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.yarnpkg.com/is-string/-/is-string-1.0.7.tgz#0dd12bf2006f255bb58f695110eff7491eebc0fd" @@ -5684,6 +6123,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.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a" @@ -5711,11 +6157,16 @@ is-windows@^1.0.0, is-windows@^1.0.2: resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d" 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.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.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" @@ -5733,11 +6184,24 @@ isobject@^3.0.0, isobject@^3.0.1: resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df" 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.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a" 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.yarnpkg.com/js-sdsl/-/js-sdsl-4.4.0.tgz#8b437dbe642daa95760400b602378ed8ffea8430" @@ -6443,7 +6907,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.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== @@ -6676,6 +7140,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.yarnpkg.com/node-fetch/-/node-fetch-2.6.9.tgz#7c7f744b5cc6eb5fd404e0c7a9fec630a55657e6" @@ -6774,6 +7245,11 @@ object-inspect@^1.12.3, object-inspect@^1.9.0: resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.3.tgz#ba62dffd67ee256c8c086dfae69e016cd1f198b9" 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.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e" @@ -6806,6 +7282,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.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.5.tgz#db5a9002489b64eef903df81d6623c07e5b4b4d3" @@ -7118,6 +7604,11 @@ posix-character-classes@^0.1.0: resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab" 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.yarnpkg.com/preferred-pm/-/preferred-pm-3.0.3.tgz#1b6338000371e3edbce52ef2e4f65eb2e73586d6" @@ -7167,6 +7658,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" + proxy-from-env@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2" @@ -7417,6 +7917,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.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2" @@ -7576,6 +8086,16 @@ ret@~0.1.10: resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc" 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.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76" @@ -7648,6 +8168,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.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" @@ -7667,6 +8197,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.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e" @@ -7771,6 +8310,28 @@ set-blocking@^2.0.0: resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7" 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.yarnpkg.com/set-value/-/set-value-2.0.1.tgz#a18d40530e6f07de4228c7defe4227af8cad005b" @@ -7953,6 +8514,13 @@ solc@0.8.15: semver "^5.5.0" tmp "0.0.33" +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.yarnpkg.com/solidity-coverage/-/solidity-coverage-0.8.2.tgz#bc39604ab7ce0a3fa7767b126b44191830c07813" @@ -8158,6 +8726,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.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz#c4a27fa026d979d79c04f17397f250a462944533" @@ -8167,6 +8745,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.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz#e90ab66aa8e4007d92ef591bbf3cd422c56bdcf4" @@ -8176,6 +8763,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.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e" @@ -8321,9 +8917,9 @@ table-layout@^1.0.2: wordwrapjs "^4.0.0" table@^6.8.0: - version "6.8.1" - resolved "https://registry.yarnpkg.com/table/-/table-6.8.1.tgz#ea2b71359fe03b017a5fbc296204471158080bdf" - integrity sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA== + version "6.8.2" + resolved "https://registry.yarnpkg.com/table/-/table-6.8.2.tgz#c5504ccf201213fa227248bdc8c5569716ac6c58" + integrity sha512-w2sfv80nrAh2VCbqR5AK27wswXhqcck2AhfnNW76beQXskGZ1V12GwS//yYVa3d3fcvAip2OUnbDAjW2k3v9fA== dependencies: ajv "^8.0.1" lodash.truncate "^4.4.2" @@ -8498,7 +9094,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.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00" integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== @@ -8508,6 +9104,11 @@ tslib@^2.1.0: resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.5.0.tgz#42bfed86f5787aeb41d031866c8f402429e0fddf" 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.yarnpkg.com/tsort/-/tsort-0.0.1.tgz#e2280f5e817f8bf4275657fd0f9aebd44f5a2786" @@ -8625,6 +9226,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.yarnpkg.com/typed-array-length/-/typed-array-length-1.0.4.tgz#89d83785e5c4098bec72e08b319651f0eac9c1bb" @@ -8634,6 +9267,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.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777" @@ -8676,6 +9321,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.yarnpkg.com/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847" @@ -8718,7 +9368,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.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== @@ -8859,6 +9509,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.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.9.tgz#307cf898025848cf995e795e8423c7f337efbde6" From 4026eeaa90f32b0e95e2293424d42d6e2fc70fdb Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 20 Jun 2024 20:48:38 +0200 Subject: [PATCH 02/25] yarn generate --- hardhat.config.ts | 2 +- .../erc20custodynew.sol/erc20custodynew.go | 4 +- .../prototypes/gateway.sol/gateway.go | 1049 +++++++++++++++-- .../prototypes/interfaces.sol/igateway.go | 202 ++++ .../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 | 4 +- 15 files changed, 5116 insertions(+), 95 deletions(-) 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 diff --git a/hardhat.config.ts b/hardhat.config.ts index 4f03ded0..23f6d43f 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -5,11 +5,11 @@ 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"; import type { HardhatUserConfig } from "hardhat/types"; -import "@openzeppelin/hardhat-upgrades"; dotenv.config(); diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go index 0917f9f4..21d9655a 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: "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", + 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: "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c6121c062000243600039600081816102c4015281816103530152818161044d015281816104dc015261087801526121c06000f3fe60806040526004361061009c5760003560e01c8063715018a611610064578063715018a61461017e5780638129fc1c146101955780638da5cb5b146101ac578063ae7a3a6f146101d7578063dda79b7514610200578063f2fde38b1461022b5761009c565b80631cff79cd146100a15780633659cfe6146100d15780634f1ef286146100fa5780635131ab591461011657806352d1902d14610153575b600080fd5b6100bb60048036038101906100b69190611554565b610254565b6040516100c89190611a10565b60405180910390f35b3480156100dd57600080fd5b506100f860048036038101906100f3919061149f565b6102c2565b005b610114600480360381019061010f91906115b4565b61044b565b005b34801561012257600080fd5b5061013d600480360381019061013891906114cc565b610588565b60405161014a9190611a10565b60405180910390f35b34801561015f57600080fd5b50610168610874565b60405161017591906119f5565b60405180910390f35b34801561018a57600080fd5b5061019361092d565b005b3480156101a157600080fd5b506101aa610941565b005b3480156101b857600080fd5b506101c1610a87565b6040516101ce9190611988565b60405180910390f35b3480156101e357600080fd5b506101fe60048036038101906101f9919061149f565b610ab1565b005b34801561020c57600080fd5b50610215610af5565b6040516102229190611988565b60405180910390f35b34801561023757600080fd5b50610252600480360381019061024d919061149f565b610b1b565b005b60606000610263858585610b9f565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f3486866040516102af93929190611bcf565b60405180910390a2809150509392505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610351576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161034890611a8f565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610390610c56565b73ffffffffffffffffffffffffffffffffffffffff16146103e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103dd90611aaf565b60405180910390fd5b6103ef81610cad565b61044881600067ffffffffffffffff81111561040e5761040d611d90565b5b6040519080825280601f01601f1916602001820160405280156104405781602001600182028036833780820191505090505b506000610cb8565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614156104da576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104d190611a8f565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610519610c56565b73ffffffffffffffffffffffffffffffffffffffff161461056f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161056690611aaf565b60405180910390fd5b61057882610cad565b61058482826001610cb8565b5050565b60608573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b81526004016105c59291906119cc565b602060405180830381600087803b1580156105df57600080fd5b505af11580156105f3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106179190611610565b506000610625868585610b9f565b90508673ffffffffffffffffffffffffffffffffffffffff1663095ea7b38760006040518363ffffffff1660e01b81526004016106639291906119a3565b602060405180830381600087803b15801561067d57600080fd5b505af1158015610691573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106b59190611610565b5060008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016106f19190611988565b60206040518083038186803b15801561070957600080fd5b505afa15801561071d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610741919061166a565b905060008111156107fd578773ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff1660e01b81526004016107a99291906119cc565b602060405180830381600087803b1580156107c357600080fd5b505af11580156107d7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107fb9190611610565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b738288888860405161085e93929190611bcf565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614610904576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108fb90611acf565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b610935610e35565b61093f6000610eb3565b565b60008060019054906101000a900460ff161590508080156109725750600160008054906101000a900460ff1660ff16105b8061099f575061098130610f79565b15801561099e5750600160008054906101000a900460ff1660ff16145b5b6109de576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109d590611b0f565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610a1b576001600060016101000a81548160ff0219169083151502179055505b610a23610f9c565b610a2b610ff5565b8015610a845760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610a7b9190611a32565b60405180910390a15b50565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610b23610e35565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610b93576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b8a90611a6f565b60405180910390fd5b610b9c81610eb3565b50565b60606000808573ffffffffffffffffffffffffffffffffffffffff16348686604051610bcc929190611958565b60006040518083038185875af1925050503d8060008114610c09576040519150601f19603f3d011682016040523d82523d6000602084013e610c0e565b606091505b509150915081610c4a576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b6000610c847f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611046565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b610cb5610e35565b50565b610ce47f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b611050565b60000160009054906101000a900460ff1615610d0857610d038361105a565b610e30565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b158015610d4e57600080fd5b505afa925050508015610d7f57506040513d601f19601f82011682018060405250810190610d7c919061163d565b60015b610dbe576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610db590611b2f565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114610e23576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e1a90611aef565b60405180910390fd5b50610e2f838383611113565b5b505050565b610e3d61113f565b73ffffffffffffffffffffffffffffffffffffffff16610e5b610a87565b73ffffffffffffffffffffffffffffffffffffffff1614610eb1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ea890611b6f565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16610feb576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fe290611baf565b60405180910390fd5b610ff3611147565b565b600060019054906101000a900460ff16611044576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161103b90611baf565b60405180910390fd5b565b6000819050919050565b6000819050919050565b61106381610f79565b6110a2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161109990611b4f565b60405180910390fd5b806110cf7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611046565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b61111c836111a8565b6000825111806111295750805b1561113a5761113883836111f7565b505b505050565b600033905090565b600060019054906101000a900460ff16611196576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161118d90611baf565b60405180910390fd5b6111a66111a161113f565b610eb3565b565b6111b18161105a565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b606061121c838360405180606001604052806027815260200161216460279139611224565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff168560405161124e9190611971565b600060405180830381855af49150503d8060008114611289576040519150601f19603f3d011682016040523d82523d6000602084013e61128e565b606091505b509150915061129f868383876112aa565b925050509392505050565b6060831561130d57600083511415611305576112c585610f79565b611304576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112fb90611b8f565b60405180910390fd5b5b829050611318565b6113178383611320565b5b949350505050565b6000825111156113335781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113679190611a4d565b60405180910390fd5b600061138361137e84611c26565b611c01565b90508281526020810184848401111561139f5761139e611dce565b5b6113aa848285611d1d565b509392505050565b6000813590506113c181612107565b92915050565b6000815190506113d68161211e565b92915050565b6000815190506113eb81612135565b92915050565b60008083601f84011261140757611406611dc4565b5b8235905067ffffffffffffffff81111561142457611423611dbf565b5b6020830191508360018202830111156114405761143f611dc9565b5b9250929050565b600082601f83011261145c5761145b611dc4565b5b813561146c848260208601611370565b91505092915050565b6000813590506114848161214c565b92915050565b6000815190506114998161214c565b92915050565b6000602082840312156114b5576114b4611dd8565b5b60006114c3848285016113b2565b91505092915050565b6000806000806000608086880312156114e8576114e7611dd8565b5b60006114f6888289016113b2565b9550506020611507888289016113b2565b945050604061151888828901611475565b935050606086013567ffffffffffffffff81111561153957611538611dd3565b5b611545888289016113f1565b92509250509295509295909350565b60008060006040848603121561156d5761156c611dd8565b5b600061157b868287016113b2565b935050602084013567ffffffffffffffff81111561159c5761159b611dd3565b5b6115a8868287016113f1565b92509250509250925092565b600080604083850312156115cb576115ca611dd8565b5b60006115d9858286016113b2565b925050602083013567ffffffffffffffff8111156115fa576115f9611dd3565b5b61160685828601611447565b9150509250929050565b60006020828403121561162657611625611dd8565b5b6000611634848285016113c7565b91505092915050565b60006020828403121561165357611652611dd8565b5b6000611661848285016113dc565b91505092915050565b6000602082840312156116805761167f611dd8565b5b600061168e8482850161148a565b91505092915050565b6116a081611c9a565b82525050565b6116af81611cb8565b82525050565b60006116c18385611c6d565b93506116ce838584611d1d565b6116d783611ddd565b840190509392505050565b60006116ee8385611c7e565b93506116fb838584611d1d565b82840190509392505050565b600061171282611c57565b61171c8185611c6d565b935061172c818560208601611d2c565b61173581611ddd565b840191505092915050565b600061174b82611c57565b6117558185611c7e565b9350611765818560208601611d2c565b80840191505092915050565b61177a81611cf9565b82525050565b61178981611d0b565b82525050565b600061179a82611c62565b6117a48185611c89565b93506117b4818560208601611d2c565b6117bd81611ddd565b840191505092915050565b60006117d5602683611c89565b91506117e082611dee565b604082019050919050565b60006117f8602c83611c89565b915061180382611e3d565b604082019050919050565b600061181b602c83611c89565b915061182682611e8c565b604082019050919050565b600061183e603883611c89565b915061184982611edb565b604082019050919050565b6000611861602983611c89565b915061186c82611f2a565b604082019050919050565b6000611884602e83611c89565b915061188f82611f79565b604082019050919050565b60006118a7602e83611c89565b91506118b282611fc8565b604082019050919050565b60006118ca602d83611c89565b91506118d582612017565b604082019050919050565b60006118ed602083611c89565b91506118f882612066565b602082019050919050565b6000611910601d83611c89565b915061191b8261208f565b602082019050919050565b6000611933602b83611c89565b915061193e826120b8565b604082019050919050565b61195281611ce2565b82525050565b60006119658284866116e2565b91508190509392505050565b600061197d8284611740565b915081905092915050565b600060208201905061199d6000830184611697565b92915050565b60006040820190506119b86000830185611697565b6119c56020830184611771565b9392505050565b60006040820190506119e16000830185611697565b6119ee6020830184611949565b9392505050565b6000602082019050611a0a60008301846116a6565b92915050565b60006020820190508181036000830152611a2a8184611707565b905092915050565b6000602082019050611a476000830184611780565b92915050565b60006020820190508181036000830152611a67818461178f565b905092915050565b60006020820190508181036000830152611a88816117c8565b9050919050565b60006020820190508181036000830152611aa8816117eb565b9050919050565b60006020820190508181036000830152611ac88161180e565b9050919050565b60006020820190508181036000830152611ae881611831565b9050919050565b60006020820190508181036000830152611b0881611854565b9050919050565b60006020820190508181036000830152611b2881611877565b9050919050565b60006020820190508181036000830152611b488161189a565b9050919050565b60006020820190508181036000830152611b68816118bd565b9050919050565b60006020820190508181036000830152611b88816118e0565b9050919050565b60006020820190508181036000830152611ba881611903565b9050919050565b60006020820190508181036000830152611bc881611926565b9050919050565b6000604082019050611be46000830186611949565b8181036020830152611bf78184866116b5565b9050949350505050565b6000611c0b611c1c565b9050611c178282611d5f565b919050565b6000604051905090565b600067ffffffffffffffff821115611c4157611c40611d90565b5b611c4a82611ddd565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000611ca582611cc2565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000611d0482611ce2565b9050919050565b6000611d1682611cec565b9050919050565b82818337600083830152505050565b60005b83811015611d4a578082015181840152602081019050611d2f565b83811115611d59576000848401525b50505050565b611d6882611ddd565b810181811067ffffffffffffffff82111715611d8757611d86611d90565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b61211081611c9a565b811461211b57600080fd5b50565b61212781611cac565b811461213257600080fd5b50565b61213e81611cb8565b811461214957600080fd5b50565b61215581611ce2565b811461216057600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220934d848f2fe7f7f01c45bd36cd514054cf8103d3b8d246498b1d56670630cdd864736f6c63430008070033", } // 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/interfaces.sol/igateway.go b/pkg/contracts/prototypes/interfaces.sol/igateway.go new file mode 100644 index 00000000..38a1ee21 --- /dev/null +++ b/pkg/contracts/prototypes/interfaces.sol/igateway.go @@ -0,0 +1,202 @@ +// 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\":\"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...) +} + +// 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 3bf56398..9d1efaa5 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -19,10 +19,10 @@ describe("Gateway and Receiver", function () { // Deploy the contracts token = await TestERC20.deploy("Test Token", "TTK"); receiver = await Receiver.deploy(); - gateway = (await upgrades.deployProxy(Gateway, [], { - kind: 'uups', - initializer: 'initialize', - })) + gateway = await upgrades.deployProxy(Gateway, [], { + initializer: "initialize", + kind: "uups", + }); custody = await Custody.deploy(gateway.address); gateway.setCustody(custody.address); diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayUniswap.spec.ts index c00fc948..7ee89a0c 100644 --- a/test/prototypes/GatewayUniswap.spec.ts +++ b/test/prototypes/GatewayUniswap.spec.ts @@ -59,8 +59,8 @@ describe("Uniswap Integration with Gateway", function () { const Gateway = await ethers.getContractFactory("Gateway"); const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); gateway = (await upgrades.deployProxy(Gateway, [], { - kind: 'uups', - initializer: 'initialize', + initializer: "initialize", + kind: "uups", })) as Gateway; custody = (await ERC20CustodyNew.deploy(gateway.address)) as ERC20CustodyNew; From fcfc2720c9932160ef6d21b4af89618443eb829e Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 21 Jun 2024 00:16:27 +0200 Subject: [PATCH 03/25] yarn install --- yarn.lock | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/yarn.lock b/yarn.lock index 8577519b..05347c34 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1476,10 +1476,10 @@ resolved "https://registry.yarnpkg.com/@nomicfoundation/hardhat-toolbox/-/hardhat-toolbox-2.0.2.tgz#ec95f23b53cb4e71a1a7091380fa223aad18f156" integrity sha512-vnN1AzxbvpSx9pfdRHbUzTRIXpMLPXnUlkW855VaDk6N1pwRaQ2gNzEmFAABk4lWf11E00PKwFd/q27HuwYrYg== -"@nomicfoundation/hardhat-verify@^2.0.3": - version "2.0.8" - resolved "https://registry.yarnpkg.com/@nomicfoundation/hardhat-verify/-/hardhat-verify-2.0.8.tgz#6a77dc03de990a1a3aa8e6dc073c393263dbf258" - integrity sha512-x/OYya7A2Kcz+3W/J78dyDHxr0ezU23DKTrRKfy5wDPCnePqnr79vm8EXqX3gYps6IjPBYyGPZ9K6E5BnrWx5Q== +"@nomicfoundation/hardhat-verify@2.0.3": + version "2.0.3" + resolved "https://registry.yarnpkg.com/@nomicfoundation/hardhat-verify/-/hardhat-verify-2.0.3.tgz#173557f8cfa53c8c9da23a326f54d24fe459ae68" + integrity sha512-ESbRu9by53wu6VvgwtMtm108RSmuNsVqXtzg061D+/4R7jaWh/Wl/8ve+p6SdDX7vA1Z3L02hDO1Q3BY4luLXQ== dependencies: "@ethersproject/abi" "^5.1.2" "@ethersproject/address" "^5.0.2" From b6b38838ff32a0056ab0a4ffe19ef00089cf7589 Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 21 Jun 2024 17:07:22 +0200 Subject: [PATCH 04/25] add unit test for gateway upgrade --- contracts/prototypes/GatewayV2.sol | 87 +++ contracts/prototypes/interfaces.sol | 2 + test/prototypes/GatewayIntegration.spec.ts | 1 + test/prototypes/GatewayUpgrade.spec.ts | 59 ++ .../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 | 1 + .../prototypes/interfaces.sol/IGateway.ts | 41 +- .../prototypes/ERC20CustodyNew__factory.ts | 2 +- .../GatewayV2.sol/GatewayV2__factory.ts | 374 ++++++++++++ .../GatewayV2.sol/Gateway__factory.ts | 374 ++++++++++++ .../prototypes/GatewayV2.sol/index.ts | 5 + .../prototypes/GatewayV2__factory.ts | 374 ++++++++++++ .../factories/contracts/prototypes/index.ts | 1 + .../interfaces.sol/IGateway__factory.ts | 24 + typechain-types/hardhat.d.ts | 9 + typechain-types/index.ts | 2 + 19 files changed, 3036 insertions(+), 2 deletions(-) create mode 100644 contracts/prototypes/GatewayV2.sol create mode 100644 test/prototypes/GatewayUpgrade.spec.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/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 diff --git a/contracts/prototypes/GatewayV2.sol b/contracts/prototypes/GatewayV2.sol new file mode 100644 index 00000000..07038216 --- /dev/null +++ b/contracts/prototypes/GatewayV2.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 GatewayV2 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 index 19d2da4d..58a474ae 100644 --- a/contracts/prototypes/interfaces.sol +++ b/contracts/prototypes/interfaces.sol @@ -8,4 +8,6 @@ interface IGateway { 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/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 9d1efaa5..cb6c7bc1 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -48,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/GatewayUpgrade.spec.ts b/test/prototypes/GatewayUpgrade.spec.ts new file mode 100644 index 00000000..695dcdf2 --- /dev/null +++ b/test/prototypes/GatewayUpgrade.spec.ts @@ -0,0 +1,59 @@ +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; + + 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 upgrade and forward call to Receiver's receiveA function", async function () { + // Upgrade Gateway contract + const GatewayV2 = await ethers.getContractFactory("GatewayV2"); + const gatewayV2 = await upgrades.upgradeProxy(gateway.address, GatewayV2); + + // 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 gatewayV2.execute(receiver.address, data, { value: value }); + await tx.wait(); + + // Listen for the event + await expect(tx).to.emit(gatewayV2, "ExecutedV2").withArgs(receiver.address, value, data); + await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gatewayV2.address, value, str, num, flag); + }); +}); 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 f240a5c2..df7d9b34 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -5,5 +5,6 @@ import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; export type { Gateway } from "./Gateway"; +export type { GatewayV2 } from "./GatewayV2"; 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 index 1711052d..969095cb 100644 --- a/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts +++ b/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts @@ -9,6 +9,7 @@ import type { CallOverrides, ContractTransaction, Overrides, + PayableOverrides, PopulatedTransaction, Signer, utils, @@ -25,11 +26,18 @@ import type { export interface IGatewayInterface extends utils.Interface { functions: { + "execute(address,bytes)": FunctionFragment; "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; }; - getFunction(nameOrSignatureOrTopic: "executeWithERC20"): FunctionFragment; + getFunction( + nameOrSignatureOrTopic: "execute" | "executeWithERC20" + ): FunctionFragment; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; encodeFunctionData( functionFragment: "executeWithERC20", values: [ @@ -40,6 +48,7 @@ export interface IGatewayInterface extends utils.Interface { ] ): string; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; decodeFunctionResult( functionFragment: "executeWithERC20", data: BytesLike @@ -75,6 +84,12 @@ export interface IGateway extends BaseContract { removeListener: OnEvent; functions: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + executeWithERC20( token: PromiseOrValue, to: PromiseOrValue, @@ -84,6 +99,12 @@ export interface IGateway extends BaseContract { ): Promise; }; + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + executeWithERC20( token: PromiseOrValue, to: PromiseOrValue, @@ -93,6 +114,12 @@ export interface IGateway extends BaseContract { ): Promise; callStatic: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + executeWithERC20( token: PromiseOrValue, to: PromiseOrValue, @@ -105,6 +132,12 @@ export interface IGateway extends BaseContract { filters: {}; estimateGas: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + executeWithERC20( token: PromiseOrValue, to: PromiseOrValue, @@ -115,6 +148,12 @@ export interface IGateway extends BaseContract { }; populateTransaction: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + executeWithERC20( token: PromiseOrValue, to: PromiseOrValue, diff --git a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts index f6896654..60aa0793 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/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/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 4fef6298..4056e80c 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -4,5 +4,6 @@ export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { Gateway__factory } from "./Gateway__factory"; +export { GatewayV2__factory } from "./GatewayV2__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 index 04761f64..20c69449 100644 --- a/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts @@ -10,6 +10,30 @@ import type { } 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: [ { diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 197e5be6..64d166c0 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -340,6 +340,10 @@ declare module "hardhat/types/runtime" { name: "Gateway", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "GatewayV2", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "IGateway", signerOrOptions?: ethers.Signer | FactoryOptions @@ -831,6 +835,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "GatewayV2", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "IGateway", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 35dbdadc..7f52b15e 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -160,6 +160,8 @@ 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 { GatewayV2 } from "./contracts/prototypes/GatewayV2"; +export { GatewayV2__factory } from "./factories/contracts/prototypes/GatewayV2__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"; From 117e9c7df942aa00089fb31c9535f0c3bc14e114 Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 21 Jun 2024 17:09:13 +0200 Subject: [PATCH 05/25] yarn generate --- .../erc20custodynew.sol/erc20custodynew.go | 2 +- .../prototypes/gatewayv2.sol/gatewayv2.go | 1475 +++++++++++++++++ .../prototypes/interfaces.sol/igateway.go | 23 +- 3 files changed, 1498 insertions(+), 2 deletions(-) create mode 100644 pkg/contracts/prototypes/gatewayv2.sol/gatewayv2.go diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go index 21d9655a..84fac379 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\":\"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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", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/gatewayv2.sol/gatewayv2.go b/pkg/contracts/prototypes/gatewayv2.sol/gatewayv2.go new file mode 100644 index 00000000..c60124b0 --- /dev/null +++ b/pkg/contracts/prototypes/gatewayv2.sol/gatewayv2.go @@ -0,0 +1,1475 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gatewayv2 + +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 +) + +// GatewayV2MetaData contains all meta data concerning the GatewayV2 contract. +var GatewayV2MetaData = &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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", +} + +// GatewayV2ABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayV2MetaData.ABI instead. +var GatewayV2ABI = GatewayV2MetaData.ABI + +// GatewayV2Bin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayV2MetaData.Bin instead. +var GatewayV2Bin = GatewayV2MetaData.Bin + +// DeployGatewayV2 deploys a new Ethereum contract, binding an instance of GatewayV2 to it. +func DeployGatewayV2(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayV2, error) { + parsed, err := GatewayV2MetaData.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(GatewayV2Bin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &GatewayV2{GatewayV2Caller: GatewayV2Caller{contract: contract}, GatewayV2Transactor: GatewayV2Transactor{contract: contract}, GatewayV2Filterer: GatewayV2Filterer{contract: contract}}, nil +} + +// GatewayV2 is an auto generated Go binding around an Ethereum contract. +type GatewayV2 struct { + GatewayV2Caller // Read-only binding to the contract + GatewayV2Transactor // Write-only binding to the contract + GatewayV2Filterer // Log filterer for contract events +} + +// GatewayV2Caller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayV2Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayV2Transactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayV2Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayV2Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayV2Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayV2Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewayV2Session struct { + Contract *GatewayV2 // 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 +} + +// GatewayV2CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayV2CallerSession struct { + Contract *GatewayV2Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayV2TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayV2TransactorSession struct { + Contract *GatewayV2Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayV2Raw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayV2Raw struct { + Contract *GatewayV2 // Generic contract binding to access the raw methods on +} + +// GatewayV2CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayV2CallerRaw struct { + Contract *GatewayV2Caller // Generic read-only contract binding to access the raw methods on +} + +// GatewayV2TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayV2TransactorRaw struct { + Contract *GatewayV2Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewGatewayV2 creates a new instance of GatewayV2, bound to a specific deployed contract. +func NewGatewayV2(address common.Address, backend bind.ContractBackend) (*GatewayV2, error) { + contract, err := bindGatewayV2(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &GatewayV2{GatewayV2Caller: GatewayV2Caller{contract: contract}, GatewayV2Transactor: GatewayV2Transactor{contract: contract}, GatewayV2Filterer: GatewayV2Filterer{contract: contract}}, nil +} + +// NewGatewayV2Caller creates a new read-only instance of GatewayV2, bound to a specific deployed contract. +func NewGatewayV2Caller(address common.Address, caller bind.ContractCaller) (*GatewayV2Caller, error) { + contract, err := bindGatewayV2(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayV2Caller{contract: contract}, nil +} + +// NewGatewayV2Transactor creates a new write-only instance of GatewayV2, bound to a specific deployed contract. +func NewGatewayV2Transactor(address common.Address, transactor bind.ContractTransactor) (*GatewayV2Transactor, error) { + contract, err := bindGatewayV2(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayV2Transactor{contract: contract}, nil +} + +// NewGatewayV2Filterer creates a new log filterer instance of GatewayV2, bound to a specific deployed contract. +func NewGatewayV2Filterer(address common.Address, filterer bind.ContractFilterer) (*GatewayV2Filterer, error) { + contract, err := bindGatewayV2(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayV2Filterer{contract: contract}, nil +} + +// bindGatewayV2 binds a generic wrapper to an already deployed contract. +func bindGatewayV2(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayV2MetaData.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 (_GatewayV2 *GatewayV2Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayV2.Contract.GatewayV2Caller.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 (_GatewayV2 *GatewayV2Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayV2.Contract.GatewayV2Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayV2 *GatewayV2Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayV2.Contract.GatewayV2Transactor.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 (_GatewayV2 *GatewayV2CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayV2.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 (_GatewayV2 *GatewayV2TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayV2.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayV2 *GatewayV2TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayV2.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 (_GatewayV2 *GatewayV2Caller) Custody(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayV2.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 (_GatewayV2 *GatewayV2Session) Custody() (common.Address, error) { + return _GatewayV2.Contract.Custody(&_GatewayV2.CallOpts) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayV2 *GatewayV2CallerSession) Custody() (common.Address, error) { + return _GatewayV2.Contract.Custody(&_GatewayV2.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayV2 *GatewayV2Caller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayV2.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 (_GatewayV2 *GatewayV2Session) Owner() (common.Address, error) { + return _GatewayV2.Contract.Owner(&_GatewayV2.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayV2 *GatewayV2CallerSession) Owner() (common.Address, error) { + return _GatewayV2.Contract.Owner(&_GatewayV2.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayV2 *GatewayV2Caller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _GatewayV2.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 (_GatewayV2 *GatewayV2Session) ProxiableUUID() ([32]byte, error) { + return _GatewayV2.Contract.ProxiableUUID(&_GatewayV2.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayV2 *GatewayV2CallerSession) ProxiableUUID() ([32]byte, error) { + return _GatewayV2.Contract.ProxiableUUID(&_GatewayV2.CallOpts) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayV2 *GatewayV2Transactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayV2.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 (_GatewayV2 *GatewayV2Session) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayV2.Contract.Execute(&_GatewayV2.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 (_GatewayV2 *GatewayV2TransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayV2.Contract.Execute(&_GatewayV2.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 (_GatewayV2 *GatewayV2Transactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayV2.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 (_GatewayV2 *GatewayV2Session) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayV2.Contract.ExecuteWithERC20(&_GatewayV2.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 (_GatewayV2 *GatewayV2TransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayV2.Contract.ExecuteWithERC20(&_GatewayV2.TransactOpts, token, to, amount, data) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayV2 *GatewayV2Transactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayV2.contract.Transact(opts, "initialize") +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayV2 *GatewayV2Session) Initialize() (*types.Transaction, error) { + return _GatewayV2.Contract.Initialize(&_GatewayV2.TransactOpts) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayV2 *GatewayV2TransactorSession) Initialize() (*types.Transaction, error) { + return _GatewayV2.Contract.Initialize(&_GatewayV2.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayV2 *GatewayV2Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayV2.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayV2 *GatewayV2Session) RenounceOwnership() (*types.Transaction, error) { + return _GatewayV2.Contract.RenounceOwnership(&_GatewayV2.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayV2 *GatewayV2TransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayV2.Contract.RenounceOwnership(&_GatewayV2.TransactOpts) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayV2 *GatewayV2Transactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { + return _GatewayV2.contract.Transact(opts, "setCustody", _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayV2 *GatewayV2Session) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayV2.Contract.SetCustody(&_GatewayV2.TransactOpts, _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayV2 *GatewayV2TransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayV2.Contract.SetCustody(&_GatewayV2.TransactOpts, _custody) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayV2 *GatewayV2Transactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _GatewayV2.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayV2 *GatewayV2Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayV2.Contract.TransferOwnership(&_GatewayV2.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayV2 *GatewayV2TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayV2.Contract.TransferOwnership(&_GatewayV2.TransactOpts, newOwner) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayV2 *GatewayV2Transactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _GatewayV2.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayV2 *GatewayV2Session) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayV2.Contract.UpgradeTo(&_GatewayV2.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayV2 *GatewayV2TransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayV2.Contract.UpgradeTo(&_GatewayV2.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayV2 *GatewayV2Transactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayV2.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 (_GatewayV2 *GatewayV2Session) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayV2.Contract.UpgradeToAndCall(&_GatewayV2.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayV2 *GatewayV2TransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayV2.Contract.UpgradeToAndCall(&_GatewayV2.TransactOpts, newImplementation, data) +} + +// GatewayV2AdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayV2 contract. +type GatewayV2AdminChangedIterator struct { + Event *GatewayV2AdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayV2AdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayV2AdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayV2AdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayV2AdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayV2AdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayV2AdminChanged represents a AdminChanged event raised by the GatewayV2 contract. +type GatewayV2AdminChanged 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 (_GatewayV2 *GatewayV2Filterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayV2AdminChangedIterator, error) { + + logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &GatewayV2AdminChangedIterator{contract: _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayV2AdminChanged) (event.Subscription, error) { + + logs, sub, err := _GatewayV2.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(GatewayV2AdminChanged) + if err := _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) ParseAdminChanged(log types.Log) (*GatewayV2AdminChanged, error) { + event := new(GatewayV2AdminChanged) + if err := _GatewayV2.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayV2BeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayV2 contract. +type GatewayV2BeaconUpgradedIterator struct { + Event *GatewayV2BeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayV2BeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayV2BeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayV2BeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayV2BeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayV2BeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayV2BeaconUpgraded represents a BeaconUpgraded event raised by the GatewayV2 contract. +type GatewayV2BeaconUpgraded 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 (_GatewayV2 *GatewayV2Filterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayV2BeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &GatewayV2BeaconUpgradedIterator{contract: _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayV2BeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayV2.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(GatewayV2BeaconUpgraded) + if err := _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) ParseBeaconUpgraded(log types.Log) (*GatewayV2BeaconUpgraded, error) { + event := new(GatewayV2BeaconUpgraded) + if err := _GatewayV2.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayV2ExecutedV2Iterator is returned from FilterExecutedV2 and is used to iterate over the raw logs and unpacked data for ExecutedV2 events raised by the GatewayV2 contract. +type GatewayV2ExecutedV2Iterator struct { + Event *GatewayV2ExecutedV2 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayV2ExecutedV2Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayV2ExecutedV2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayV2ExecutedV2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayV2ExecutedV2Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayV2ExecutedV2Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayV2ExecutedV2 represents a ExecutedV2 event raised by the GatewayV2 contract. +type GatewayV2ExecutedV2 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 (_GatewayV2 *GatewayV2Filterer) FilterExecutedV2(opts *bind.FilterOpts, destination []common.Address) (*GatewayV2ExecutedV2Iterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "ExecutedV2", destinationRule) + if err != nil { + return nil, err + } + return &GatewayV2ExecutedV2Iterator{contract: _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) WatchExecutedV2(opts *bind.WatchOpts, sink chan<- *GatewayV2ExecutedV2, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayV2.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(GatewayV2ExecutedV2) + if err := _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) ParseExecutedV2(log types.Log) (*GatewayV2ExecutedV2, error) { + event := new(GatewayV2ExecutedV2) + if err := _GatewayV2.contract.UnpackLog(event, "ExecutedV2", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayV2ExecutedWithERC20V2Iterator is returned from FilterExecutedWithERC20V2 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20V2 events raised by the GatewayV2 contract. +type GatewayV2ExecutedWithERC20V2Iterator struct { + Event *GatewayV2ExecutedWithERC20V2 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayV2ExecutedWithERC20V2Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayV2ExecutedWithERC20V2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayV2ExecutedWithERC20V2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayV2ExecutedWithERC20V2Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayV2ExecutedWithERC20V2Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayV2ExecutedWithERC20V2 represents a ExecutedWithERC20V2 event raised by the GatewayV2 contract. +type GatewayV2ExecutedWithERC20V2 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 (_GatewayV2 *GatewayV2Filterer) FilterExecutedWithERC20V2(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayV2ExecutedWithERC20V2Iterator, 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 := _GatewayV2.contract.FilterLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayV2ExecutedWithERC20V2Iterator{contract: _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) WatchExecutedWithERC20V2(opts *bind.WatchOpts, sink chan<- *GatewayV2ExecutedWithERC20V2, 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 := _GatewayV2.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(GatewayV2ExecutedWithERC20V2) + if err := _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) ParseExecutedWithERC20V2(log types.Log) (*GatewayV2ExecutedWithERC20V2, error) { + event := new(GatewayV2ExecutedWithERC20V2) + if err := _GatewayV2.contract.UnpackLog(event, "ExecutedWithERC20V2", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayV2InitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayV2 contract. +type GatewayV2InitializedIterator struct { + Event *GatewayV2Initialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayV2InitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayV2Initialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayV2Initialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayV2InitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayV2InitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayV2Initialized represents a Initialized event raised by the GatewayV2 contract. +type GatewayV2Initialized 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 (_GatewayV2 *GatewayV2Filterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayV2InitializedIterator, error) { + + logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &GatewayV2InitializedIterator{contract: _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayV2Initialized) (event.Subscription, error) { + + logs, sub, err := _GatewayV2.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(GatewayV2Initialized) + if err := _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) ParseInitialized(log types.Log) (*GatewayV2Initialized, error) { + event := new(GatewayV2Initialized) + if err := _GatewayV2.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayV2OwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayV2 contract. +type GatewayV2OwnershipTransferredIterator struct { + Event *GatewayV2OwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayV2OwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayV2OwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayV2OwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayV2OwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayV2OwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayV2OwnershipTransferred represents a OwnershipTransferred event raised by the GatewayV2 contract. +type GatewayV2OwnershipTransferred 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 (_GatewayV2 *GatewayV2Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayV2OwnershipTransferredIterator, 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 := _GatewayV2.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &GatewayV2OwnershipTransferredIterator{contract: _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayV2OwnershipTransferred, 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 := _GatewayV2.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(GatewayV2OwnershipTransferred) + if err := _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) ParseOwnershipTransferred(log types.Log) (*GatewayV2OwnershipTransferred, error) { + event := new(GatewayV2OwnershipTransferred) + if err := _GatewayV2.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayV2UpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayV2 contract. +type GatewayV2UpgradedIterator struct { + Event *GatewayV2Upgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayV2UpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayV2Upgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayV2Upgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayV2UpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayV2UpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayV2Upgraded represents a Upgraded event raised by the GatewayV2 contract. +type GatewayV2Upgraded 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 (_GatewayV2 *GatewayV2Filterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayV2UpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &GatewayV2UpgradedIterator{contract: _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayV2Upgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayV2.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(GatewayV2Upgraded) + if err := _GatewayV2.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 (_GatewayV2 *GatewayV2Filterer) ParseUpgraded(log types.Log) (*GatewayV2Upgraded, error) { + event := new(GatewayV2Upgraded) + if err := _GatewayV2.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 index 38a1ee21..34981e17 100644 --- a/pkg/contracts/prototypes/interfaces.sol/igateway.go +++ b/pkg/contracts/prototypes/interfaces.sol/igateway.go @@ -31,7 +31,7 @@ var ( // IGatewayMetaData contains all meta data concerning the IGateway contract. var IGatewayMetaData = &bind.MetaData{ - ABI: "[{\"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\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", } // IGatewayABI is the input ABI used to generate the binding from. @@ -180,6 +180,27 @@ func (_IGateway *IGatewayTransactorRaw) Transact(opts *bind.TransactOpts, method 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) From 99e39946b90cf2577af10f911cc4733247d34bed Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 21 Jun 2024 19:24:17 +0200 Subject: [PATCH 06/25] PR comments --- .../{GatewayV2.sol => GatewayUpgradeTest.sol} | 2 +- test/prototypes/GatewayUpgrade.spec.ts | 19 +- .../prototypes/GatewayUpgradeTest.ts | 559 ++++++++++++++++++ typechain-types/contracts/prototypes/index.ts | 2 +- .../prototypes/GatewayUpgradeTest__factory.ts | 374 ++++++++++++ .../factories/contracts/prototypes/index.ts | 2 +- typechain-types/hardhat.d.ts | 8 +- typechain-types/index.ts | 4 +- 8 files changed, 954 insertions(+), 16 deletions(-) rename contracts/prototypes/{GatewayV2.sol => GatewayUpgradeTest.sol} (97%) create mode 100644 typechain-types/contracts/prototypes/GatewayUpgradeTest.ts create mode 100644 typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts diff --git a/contracts/prototypes/GatewayV2.sol b/contracts/prototypes/GatewayUpgradeTest.sol similarity index 97% rename from contracts/prototypes/GatewayV2.sol rename to contracts/prototypes/GatewayUpgradeTest.sol index 07038216..0a827536 100644 --- a/contracts/prototypes/GatewayV2.sol +++ b/contracts/prototypes/GatewayUpgradeTest.sol @@ -10,7 +10,7 @@ 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 GatewayV2 is Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { error ExecutionFailed(); address public custody; diff --git a/test/prototypes/GatewayUpgrade.spec.ts b/test/prototypes/GatewayUpgrade.spec.ts index 695dcdf2..cf731beb 100644 --- a/test/prototypes/GatewayUpgrade.spec.ts +++ b/test/prototypes/GatewayUpgrade.spec.ts @@ -7,14 +7,14 @@ describe("Gateway upgrade", function () { let gateway: Contract; let token: Contract; let custody: Contract; - let owner: any, destination: any; + 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] = await ethers.getSigners(); + [owner, destination, randomSigner] = await ethers.getSigners(); // Deploy the contracts token = await TestERC20.deploy("Test Token", "TTK"); @@ -36,8 +36,13 @@ describe("Gateway upgrade", function () { it("should upgrade and forward call to Receiver's receiveA function", async function () { // Upgrade Gateway contract - const GatewayV2 = await ethers.getContractFactory("GatewayV2"); - const gatewayV2 = await upgrades.upgradeProxy(gateway.address, GatewayV2); + // 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!"; @@ -49,11 +54,11 @@ describe("Gateway upgrade", function () { const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); // Call execute on the GatewayV2 contract - const tx = await gatewayV2.execute(receiver.address, data, { value: value }); + const tx = await gatewayUpgradeTest.execute(receiver.address, data, { value: value }); await tx.wait(); // Listen for the event - await expect(tx).to.emit(gatewayV2, "ExecutedV2").withArgs(receiver.address, value, data); - await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gatewayV2.address, value, str, num, flag); + 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/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/index.ts b/typechain-types/contracts/prototypes/index.ts index df7d9b34..8e3200c1 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -5,6 +5,6 @@ import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; export type { Gateway } from "./Gateway"; -export type { GatewayV2 } from "./GatewayV2"; +export type { GatewayUpgradeTest } from "./GatewayUpgradeTest"; export type { Receiver } from "./Receiver"; export type { TestERC20 } from "./TestERC20"; 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/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 4056e80c..6fb60d1c 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -4,6 +4,6 @@ export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { Gateway__factory } from "./Gateway__factory"; -export { GatewayV2__factory } from "./GatewayV2__factory"; +export { GatewayUpgradeTest__factory } from "./GatewayUpgradeTest__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 64d166c0..e98d4f69 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -341,9 +341,9 @@ declare module "hardhat/types/runtime" { signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; getContractFactory( - name: "GatewayV2", + name: "GatewayUpgradeTest", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( name: "IGateway", signerOrOptions?: ethers.Signer | FactoryOptions @@ -836,10 +836,10 @@ declare module "hardhat/types/runtime" { signer?: ethers.Signer ): Promise; getContractAt( - name: "GatewayV2", + name: "GatewayUpgradeTest", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( name: "IGateway", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 7f52b15e..6f13ad23 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -160,8 +160,8 @@ 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 { GatewayV2 } from "./contracts/prototypes/GatewayV2"; -export { GatewayV2__factory } from "./factories/contracts/prototypes/GatewayV2__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"; From 77df0e43af554ee6d992c70949a9f4e3327a4ea4 Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 21 Jun 2024 19:25:18 +0200 Subject: [PATCH 07/25] yarn generate --- .../gatewayupgradetest.go} | 570 +++++++++--------- test/prototypes/GatewayUpgrade.spec.ts | 4 +- 2 files changed, 288 insertions(+), 286 deletions(-) rename pkg/contracts/prototypes/{gatewayv2.sol/gatewayv2.go => gatewayupgradetest.sol/gatewayupgradetest.go} (66%) diff --git a/pkg/contracts/prototypes/gatewayv2.sol/gatewayv2.go b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go similarity index 66% rename from pkg/contracts/prototypes/gatewayv2.sol/gatewayv2.go rename to pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go index c60124b0..8a542d44 100644 --- a/pkg/contracts/prototypes/gatewayv2.sol/gatewayv2.go +++ b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package gatewayv2 +package gatewayupgradetest import ( "errors" @@ -29,23 +29,23 @@ var ( _ = abi.ConvertType ) -// GatewayV2MetaData contains all meta data concerning the GatewayV2 contract. -var GatewayV2MetaData = &bind.MetaData{ +// 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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", + Bin: "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", } -// GatewayV2ABI is the input ABI used to generate the binding from. -// Deprecated: Use GatewayV2MetaData.ABI instead. -var GatewayV2ABI = GatewayV2MetaData.ABI +// GatewayUpgradeTestABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayUpgradeTestMetaData.ABI instead. +var GatewayUpgradeTestABI = GatewayUpgradeTestMetaData.ABI -// GatewayV2Bin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use GatewayV2MetaData.Bin instead. -var GatewayV2Bin = GatewayV2MetaData.Bin +// GatewayUpgradeTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayUpgradeTestMetaData.Bin instead. +var GatewayUpgradeTestBin = GatewayUpgradeTestMetaData.Bin -// DeployGatewayV2 deploys a new Ethereum contract, binding an instance of GatewayV2 to it. -func DeployGatewayV2(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayV2, error) { - parsed, err := GatewayV2MetaData.GetAbi() +// 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 } @@ -53,111 +53,111 @@ func DeployGatewayV2(auth *bind.TransactOpts, backend bind.ContractBackend) (com return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(GatewayV2Bin), backend) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(GatewayUpgradeTestBin), backend) if err != nil { return common.Address{}, nil, nil, err } - return address, tx, &GatewayV2{GatewayV2Caller: GatewayV2Caller{contract: contract}, GatewayV2Transactor: GatewayV2Transactor{contract: contract}, GatewayV2Filterer: GatewayV2Filterer{contract: contract}}, nil + return address, tx, &GatewayUpgradeTest{GatewayUpgradeTestCaller: GatewayUpgradeTestCaller{contract: contract}, GatewayUpgradeTestTransactor: GatewayUpgradeTestTransactor{contract: contract}, GatewayUpgradeTestFilterer: GatewayUpgradeTestFilterer{contract: contract}}, nil } -// GatewayV2 is an auto generated Go binding around an Ethereum contract. -type GatewayV2 struct { - GatewayV2Caller // Read-only binding to the contract - GatewayV2Transactor // Write-only binding to the contract - GatewayV2Filterer // Log filterer for contract events +// 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 } -// GatewayV2Caller is an auto generated read-only Go binding around an Ethereum contract. -type GatewayV2Caller struct { +// 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 } -// GatewayV2Transactor is an auto generated write-only Go binding around an Ethereum contract. -type GatewayV2Transactor struct { +// 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 } -// GatewayV2Filterer is an auto generated log filtering Go binding around an Ethereum contract events. -type GatewayV2Filterer struct { +// 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 } -// GatewayV2Session is an auto generated Go binding around an Ethereum contract, +// GatewayUpgradeTestSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type GatewayV2Session struct { - Contract *GatewayV2 // 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 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 } -// GatewayV2CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// GatewayUpgradeTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type GatewayV2CallerSession struct { - Contract *GatewayV2Caller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session +type GatewayUpgradeTestCallerSession struct { + Contract *GatewayUpgradeTestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session } -// GatewayV2TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// GatewayUpgradeTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type GatewayV2TransactorSession struct { - Contract *GatewayV2Transactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +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 } -// GatewayV2Raw is an auto generated low-level Go binding around an Ethereum contract. -type GatewayV2Raw struct { - Contract *GatewayV2 // Generic contract binding to access the raw methods on +// 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 } -// GatewayV2CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type GatewayV2CallerRaw struct { - Contract *GatewayV2Caller // Generic read-only 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 } -// GatewayV2TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type GatewayV2TransactorRaw struct { - Contract *GatewayV2Transactor // Generic write-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 } -// NewGatewayV2 creates a new instance of GatewayV2, bound to a specific deployed contract. -func NewGatewayV2(address common.Address, backend bind.ContractBackend) (*GatewayV2, error) { - contract, err := bindGatewayV2(address, backend, backend, backend) +// 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 &GatewayV2{GatewayV2Caller: GatewayV2Caller{contract: contract}, GatewayV2Transactor: GatewayV2Transactor{contract: contract}, GatewayV2Filterer: GatewayV2Filterer{contract: contract}}, nil + return &GatewayUpgradeTest{GatewayUpgradeTestCaller: GatewayUpgradeTestCaller{contract: contract}, GatewayUpgradeTestTransactor: GatewayUpgradeTestTransactor{contract: contract}, GatewayUpgradeTestFilterer: GatewayUpgradeTestFilterer{contract: contract}}, nil } -// NewGatewayV2Caller creates a new read-only instance of GatewayV2, bound to a specific deployed contract. -func NewGatewayV2Caller(address common.Address, caller bind.ContractCaller) (*GatewayV2Caller, error) { - contract, err := bindGatewayV2(address, caller, nil, 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 &GatewayV2Caller{contract: contract}, nil + return &GatewayUpgradeTestCaller{contract: contract}, nil } -// NewGatewayV2Transactor creates a new write-only instance of GatewayV2, bound to a specific deployed contract. -func NewGatewayV2Transactor(address common.Address, transactor bind.ContractTransactor) (*GatewayV2Transactor, error) { - contract, err := bindGatewayV2(address, nil, transactor, 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 &GatewayV2Transactor{contract: contract}, nil + return &GatewayUpgradeTestTransactor{contract: contract}, nil } -// NewGatewayV2Filterer creates a new log filterer instance of GatewayV2, bound to a specific deployed contract. -func NewGatewayV2Filterer(address common.Address, filterer bind.ContractFilterer) (*GatewayV2Filterer, error) { - contract, err := bindGatewayV2(address, nil, nil, filterer) +// 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 &GatewayV2Filterer{contract: contract}, nil + return &GatewayUpgradeTestFilterer{contract: contract}, nil } -// bindGatewayV2 binds a generic wrapper to an already deployed contract. -func bindGatewayV2(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := GatewayV2MetaData.GetAbi() +// 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 } @@ -168,46 +168,46 @@ func bindGatewayV2(address common.Address, caller bind.ContractCaller, transacto // 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 (_GatewayV2 *GatewayV2Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayV2.Contract.GatewayV2Caller.contract.Call(opts, result, method, params...) +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 (_GatewayV2 *GatewayV2Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayV2.Contract.GatewayV2Transactor.contract.Transfer(opts) +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 (_GatewayV2 *GatewayV2Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayV2.Contract.GatewayV2Transactor.contract.Transact(opts, method, params...) +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 (_GatewayV2 *GatewayV2CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayV2.Contract.contract.Call(opts, result, method, params...) +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 (_GatewayV2 *GatewayV2TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayV2.Contract.contract.Transfer(opts) +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 (_GatewayV2 *GatewayV2TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayV2.Contract.contract.Transact(opts, method, params...) +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 (_GatewayV2 *GatewayV2Caller) Custody(opts *bind.CallOpts) (common.Address, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Custody(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayV2.contract.Call(opts, &out, "custody") + err := _GatewayUpgradeTest.contract.Call(opts, &out, "custody") if err != nil { return *new(common.Address), err @@ -222,23 +222,23 @@ func (_GatewayV2 *GatewayV2Caller) Custody(opts *bind.CallOpts) (common.Address, // Custody is a free data retrieval call binding the contract method 0xdda79b75. // // Solidity: function custody() view returns(address) -func (_GatewayV2 *GatewayV2Session) Custody() (common.Address, error) { - return _GatewayV2.Contract.Custody(&_GatewayV2.CallOpts) +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 (_GatewayV2 *GatewayV2CallerSession) Custody() (common.Address, error) { - return _GatewayV2.Contract.Custody(&_GatewayV2.CallOpts) +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 (_GatewayV2 *GatewayV2Caller) Owner(opts *bind.CallOpts) (common.Address, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Owner(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayV2.contract.Call(opts, &out, "owner") + err := _GatewayUpgradeTest.contract.Call(opts, &out, "owner") if err != nil { return *new(common.Address), err @@ -253,23 +253,23 @@ func (_GatewayV2 *GatewayV2Caller) Owner(opts *bind.CallOpts) (common.Address, e // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // // Solidity: function owner() view returns(address) -func (_GatewayV2 *GatewayV2Session) Owner() (common.Address, error) { - return _GatewayV2.Contract.Owner(&_GatewayV2.CallOpts) +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 (_GatewayV2 *GatewayV2CallerSession) Owner() (common.Address, error) { - return _GatewayV2.Contract.Owner(&_GatewayV2.CallOpts) +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 (_GatewayV2 *GatewayV2Caller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { var out []interface{} - err := _GatewayV2.contract.Call(opts, &out, "proxiableUUID") + err := _GatewayUpgradeTest.contract.Call(opts, &out, "proxiableUUID") if err != nil { return *new([32]byte), err @@ -284,188 +284,188 @@ func (_GatewayV2 *GatewayV2Caller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, // ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. // // Solidity: function proxiableUUID() view returns(bytes32) -func (_GatewayV2 *GatewayV2Session) ProxiableUUID() ([32]byte, error) { - return _GatewayV2.Contract.ProxiableUUID(&_GatewayV2.CallOpts) +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 (_GatewayV2 *GatewayV2CallerSession) ProxiableUUID() ([32]byte, error) { - return _GatewayV2.Contract.ProxiableUUID(&_GatewayV2.CallOpts) +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 (_GatewayV2 *GatewayV2Transactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayV2.contract.Transact(opts, "execute", destination, data) +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 (_GatewayV2 *GatewayV2Session) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayV2.Contract.Execute(&_GatewayV2.TransactOpts, destination, data) +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 (_GatewayV2 *GatewayV2TransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayV2.Contract.Execute(&_GatewayV2.TransactOpts, destination, data) +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 (_GatewayV2 *GatewayV2Transactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayV2.contract.Transact(opts, "executeWithERC20", token, to, amount, data) +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 (_GatewayV2 *GatewayV2Session) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayV2.Contract.ExecuteWithERC20(&_GatewayV2.TransactOpts, token, to, amount, data) +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 (_GatewayV2 *GatewayV2TransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayV2.Contract.ExecuteWithERC20(&_GatewayV2.TransactOpts, token, to, amount, data) +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 (_GatewayV2 *GatewayV2Transactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayV2.contract.Transact(opts, "initialize") +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 (_GatewayV2 *GatewayV2Session) Initialize() (*types.Transaction, error) { - return _GatewayV2.Contract.Initialize(&_GatewayV2.TransactOpts) +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 (_GatewayV2 *GatewayV2TransactorSession) Initialize() (*types.Transaction, error) { - return _GatewayV2.Contract.Initialize(&_GatewayV2.TransactOpts) +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 (_GatewayV2 *GatewayV2Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayV2.contract.Transact(opts, "renounceOwnership") +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 (_GatewayV2 *GatewayV2Session) RenounceOwnership() (*types.Transaction, error) { - return _GatewayV2.Contract.RenounceOwnership(&_GatewayV2.TransactOpts) +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 (_GatewayV2 *GatewayV2TransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _GatewayV2.Contract.RenounceOwnership(&_GatewayV2.TransactOpts) +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 (_GatewayV2 *GatewayV2Transactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { - return _GatewayV2.contract.Transact(opts, "setCustody", _custody) +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 (_GatewayV2 *GatewayV2Session) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _GatewayV2.Contract.SetCustody(&_GatewayV2.TransactOpts, _custody) +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 (_GatewayV2 *GatewayV2TransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _GatewayV2.Contract.SetCustody(&_GatewayV2.TransactOpts, _custody) +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 (_GatewayV2 *GatewayV2Transactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _GatewayV2.contract.Transact(opts, "transferOwnership", newOwner) +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 (_GatewayV2 *GatewayV2Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _GatewayV2.Contract.TransferOwnership(&_GatewayV2.TransactOpts, newOwner) +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 (_GatewayV2 *GatewayV2TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _GatewayV2.Contract.TransferOwnership(&_GatewayV2.TransactOpts, newOwner) +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 (_GatewayV2 *GatewayV2Transactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { - return _GatewayV2.contract.Transact(opts, "upgradeTo", newImplementation) +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 (_GatewayV2 *GatewayV2Session) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _GatewayV2.Contract.UpgradeTo(&_GatewayV2.TransactOpts, newImplementation) +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 (_GatewayV2 *GatewayV2TransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _GatewayV2.Contract.UpgradeTo(&_GatewayV2.TransactOpts, newImplementation) +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 (_GatewayV2 *GatewayV2Transactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayV2.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +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 (_GatewayV2 *GatewayV2Session) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayV2.Contract.UpgradeToAndCall(&_GatewayV2.TransactOpts, newImplementation, data) +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 (_GatewayV2 *GatewayV2TransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayV2.Contract.UpgradeToAndCall(&_GatewayV2.TransactOpts, newImplementation, data) +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.UpgradeToAndCall(&_GatewayUpgradeTest.TransactOpts, newImplementation, data) } -// GatewayV2AdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayV2 contract. -type GatewayV2AdminChangedIterator struct { - Event *GatewayV2AdminChanged // Event containing the contract specifics and raw log +// 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 @@ -479,7 +479,7 @@ type GatewayV2AdminChangedIterator 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 *GatewayV2AdminChangedIterator) Next() bool { +func (it *GatewayUpgradeTestAdminChangedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -488,7 +488,7 @@ func (it *GatewayV2AdminChangedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayV2AdminChanged) + it.Event = new(GatewayUpgradeTestAdminChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -503,7 +503,7 @@ func (it *GatewayV2AdminChangedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayV2AdminChanged) + it.Event = new(GatewayUpgradeTestAdminChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -519,19 +519,19 @@ func (it *GatewayV2AdminChangedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayV2AdminChangedIterator) Error() error { +func (it *GatewayUpgradeTestAdminChangedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayV2AdminChangedIterator) Close() error { +func (it *GatewayUpgradeTestAdminChangedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayV2AdminChanged represents a AdminChanged event raised by the GatewayV2 contract. -type GatewayV2AdminChanged struct { +// 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 @@ -540,21 +540,21 @@ type GatewayV2AdminChanged struct { // FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. // // Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_GatewayV2 *GatewayV2Filterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayV2AdminChangedIterator, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayUpgradeTestAdminChangedIterator, error) { - logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "AdminChanged") + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "AdminChanged") if err != nil { return nil, err } - return &GatewayV2AdminChangedIterator{contract: _GatewayV2.contract, event: "AdminChanged", logs: logs, sub: sub}, nil + 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 (_GatewayV2 *GatewayV2Filterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayV2AdminChanged) (event.Subscription, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestAdminChanged) (event.Subscription, error) { - logs, sub, err := _GatewayV2.contract.WatchLogs(opts, "AdminChanged") + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "AdminChanged") if err != nil { return nil, err } @@ -564,8 +564,8 @@ func (_GatewayV2 *GatewayV2Filterer) WatchAdminChanged(opts *bind.WatchOpts, sin select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayV2AdminChanged) - if err := _GatewayV2.contract.UnpackLog(event, "AdminChanged", log); err != nil { + event := new(GatewayUpgradeTestAdminChanged) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "AdminChanged", log); err != nil { return err } event.Raw = log @@ -589,18 +589,18 @@ func (_GatewayV2 *GatewayV2Filterer) WatchAdminChanged(opts *bind.WatchOpts, sin // ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. // // Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_GatewayV2 *GatewayV2Filterer) ParseAdminChanged(log types.Log) (*GatewayV2AdminChanged, error) { - event := new(GatewayV2AdminChanged) - if err := _GatewayV2.contract.UnpackLog(event, "AdminChanged", log); err != nil { +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 } -// GatewayV2BeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayV2 contract. -type GatewayV2BeaconUpgradedIterator struct { - Event *GatewayV2BeaconUpgraded // Event containing the contract specifics and raw log +// 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 @@ -614,7 +614,7 @@ type GatewayV2BeaconUpgradedIterator 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 *GatewayV2BeaconUpgradedIterator) Next() bool { +func (it *GatewayUpgradeTestBeaconUpgradedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -623,7 +623,7 @@ func (it *GatewayV2BeaconUpgradedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayV2BeaconUpgraded) + it.Event = new(GatewayUpgradeTestBeaconUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -638,7 +638,7 @@ func (it *GatewayV2BeaconUpgradedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayV2BeaconUpgraded) + it.Event = new(GatewayUpgradeTestBeaconUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -654,19 +654,19 @@ func (it *GatewayV2BeaconUpgradedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayV2BeaconUpgradedIterator) Error() error { +func (it *GatewayUpgradeTestBeaconUpgradedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayV2BeaconUpgradedIterator) Close() error { +func (it *GatewayUpgradeTestBeaconUpgradedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayV2BeaconUpgraded represents a BeaconUpgraded event raised by the GatewayV2 contract. -type GatewayV2BeaconUpgraded struct { +// GatewayUpgradeTestBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestBeaconUpgraded struct { Beacon common.Address Raw types.Log // Blockchain specific contextual infos } @@ -674,31 +674,31 @@ type GatewayV2BeaconUpgraded struct { // FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. // // Solidity: event BeaconUpgraded(address indexed beacon) -func (_GatewayV2 *GatewayV2Filterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayV2BeaconUpgradedIterator, error) { +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 := _GatewayV2.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) if err != nil { return nil, err } - return &GatewayV2BeaconUpgradedIterator{contract: _GatewayV2.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil + 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 (_GatewayV2 *GatewayV2Filterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayV2BeaconUpgraded, beacon []common.Address) (event.Subscription, error) { +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 := _GatewayV2.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) if err != nil { return nil, err } @@ -708,8 +708,8 @@ func (_GatewayV2 *GatewayV2Filterer) WatchBeaconUpgraded(opts *bind.WatchOpts, s select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayV2BeaconUpgraded) - if err := _GatewayV2.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + event := new(GatewayUpgradeTestBeaconUpgraded) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { return err } event.Raw = log @@ -733,18 +733,18 @@ func (_GatewayV2 *GatewayV2Filterer) WatchBeaconUpgraded(opts *bind.WatchOpts, s // ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. // // Solidity: event BeaconUpgraded(address indexed beacon) -func (_GatewayV2 *GatewayV2Filterer) ParseBeaconUpgraded(log types.Log) (*GatewayV2BeaconUpgraded, error) { - event := new(GatewayV2BeaconUpgraded) - if err := _GatewayV2.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { +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 } -// GatewayV2ExecutedV2Iterator is returned from FilterExecutedV2 and is used to iterate over the raw logs and unpacked data for ExecutedV2 events raised by the GatewayV2 contract. -type GatewayV2ExecutedV2Iterator struct { - Event *GatewayV2ExecutedV2 // Event containing the contract specifics and raw log +// 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 @@ -758,7 +758,7 @@ type GatewayV2ExecutedV2Iterator 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 *GatewayV2ExecutedV2Iterator) Next() bool { +func (it *GatewayUpgradeTestExecutedV2Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -767,7 +767,7 @@ func (it *GatewayV2ExecutedV2Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayV2ExecutedV2) + it.Event = new(GatewayUpgradeTestExecutedV2) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -782,7 +782,7 @@ func (it *GatewayV2ExecutedV2Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayV2ExecutedV2) + it.Event = new(GatewayUpgradeTestExecutedV2) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -798,19 +798,19 @@ func (it *GatewayV2ExecutedV2Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayV2ExecutedV2Iterator) Error() error { +func (it *GatewayUpgradeTestExecutedV2Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayV2ExecutedV2Iterator) Close() error { +func (it *GatewayUpgradeTestExecutedV2Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayV2ExecutedV2 represents a ExecutedV2 event raised by the GatewayV2 contract. -type GatewayV2ExecutedV2 struct { +// GatewayUpgradeTestExecutedV2 represents a ExecutedV2 event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestExecutedV2 struct { Destination common.Address Value *big.Int Data []byte @@ -820,31 +820,31 @@ type GatewayV2ExecutedV2 struct { // FilterExecutedV2 is a free log retrieval operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. // // Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) -func (_GatewayV2 *GatewayV2Filterer) FilterExecutedV2(opts *bind.FilterOpts, destination []common.Address) (*GatewayV2ExecutedV2Iterator, error) { +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 := _GatewayV2.contract.FilterLogs(opts, "ExecutedV2", destinationRule) + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedV2", destinationRule) if err != nil { return nil, err } - return &GatewayV2ExecutedV2Iterator{contract: _GatewayV2.contract, event: "ExecutedV2", logs: logs, sub: sub}, nil + 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 (_GatewayV2 *GatewayV2Filterer) WatchExecutedV2(opts *bind.WatchOpts, sink chan<- *GatewayV2ExecutedV2, destination []common.Address) (event.Subscription, error) { +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 := _GatewayV2.contract.WatchLogs(opts, "ExecutedV2", destinationRule) + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedV2", destinationRule) if err != nil { return nil, err } @@ -854,8 +854,8 @@ func (_GatewayV2 *GatewayV2Filterer) WatchExecutedV2(opts *bind.WatchOpts, sink select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayV2ExecutedV2) - if err := _GatewayV2.contract.UnpackLog(event, "ExecutedV2", log); err != nil { + event := new(GatewayUpgradeTestExecutedV2) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedV2", log); err != nil { return err } event.Raw = log @@ -879,18 +879,18 @@ func (_GatewayV2 *GatewayV2Filterer) WatchExecutedV2(opts *bind.WatchOpts, sink // ParseExecutedV2 is a log parse operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. // // Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) -func (_GatewayV2 *GatewayV2Filterer) ParseExecutedV2(log types.Log) (*GatewayV2ExecutedV2, error) { - event := new(GatewayV2ExecutedV2) - if err := _GatewayV2.contract.UnpackLog(event, "ExecutedV2", log); err != nil { +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 } -// GatewayV2ExecutedWithERC20V2Iterator is returned from FilterExecutedWithERC20V2 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20V2 events raised by the GatewayV2 contract. -type GatewayV2ExecutedWithERC20V2Iterator struct { - Event *GatewayV2ExecutedWithERC20V2 // Event containing the contract specifics and raw log +// 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 @@ -904,7 +904,7 @@ type GatewayV2ExecutedWithERC20V2Iterator 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 *GatewayV2ExecutedWithERC20V2Iterator) Next() bool { +func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -913,7 +913,7 @@ func (it *GatewayV2ExecutedWithERC20V2Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayV2ExecutedWithERC20V2) + it.Event = new(GatewayUpgradeTestExecutedWithERC20V2) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -928,7 +928,7 @@ func (it *GatewayV2ExecutedWithERC20V2Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayV2ExecutedWithERC20V2) + it.Event = new(GatewayUpgradeTestExecutedWithERC20V2) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -944,19 +944,19 @@ func (it *GatewayV2ExecutedWithERC20V2Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayV2ExecutedWithERC20V2Iterator) Error() error { +func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayV2ExecutedWithERC20V2Iterator) Close() error { +func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayV2ExecutedWithERC20V2 represents a ExecutedWithERC20V2 event raised by the GatewayV2 contract. -type GatewayV2ExecutedWithERC20V2 struct { +// GatewayUpgradeTestExecutedWithERC20V2 represents a ExecutedWithERC20V2 event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestExecutedWithERC20V2 struct { Token common.Address To common.Address Amount *big.Int @@ -967,7 +967,7 @@ type GatewayV2ExecutedWithERC20V2 struct { // 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 (_GatewayV2 *GatewayV2Filterer) FilterExecutedWithERC20V2(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayV2ExecutedWithERC20V2Iterator, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedWithERC20V2(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayUpgradeTestExecutedWithERC20V2Iterator, error) { var tokenRule []interface{} for _, tokenItem := range token { @@ -978,17 +978,17 @@ func (_GatewayV2 *GatewayV2Filterer) FilterExecutedWithERC20V2(opts *bind.Filter toRule = append(toRule, toItem) } - logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) if err != nil { return nil, err } - return &GatewayV2ExecutedWithERC20V2Iterator{contract: _GatewayV2.contract, event: "ExecutedWithERC20V2", logs: logs, sub: sub}, nil + 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 (_GatewayV2 *GatewayV2Filterer) WatchExecutedWithERC20V2(opts *bind.WatchOpts, sink chan<- *GatewayV2ExecutedWithERC20V2, token []common.Address, to []common.Address) (event.Subscription, error) { +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 { @@ -999,7 +999,7 @@ func (_GatewayV2 *GatewayV2Filterer) WatchExecutedWithERC20V2(opts *bind.WatchOp toRule = append(toRule, toItem) } - logs, sub, err := _GatewayV2.contract.WatchLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) if err != nil { return nil, err } @@ -1009,8 +1009,8 @@ func (_GatewayV2 *GatewayV2Filterer) WatchExecutedWithERC20V2(opts *bind.WatchOp select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayV2ExecutedWithERC20V2) - if err := _GatewayV2.contract.UnpackLog(event, "ExecutedWithERC20V2", log); err != nil { + event := new(GatewayUpgradeTestExecutedWithERC20V2) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20V2", log); err != nil { return err } event.Raw = log @@ -1034,18 +1034,18 @@ func (_GatewayV2 *GatewayV2Filterer) WatchExecutedWithERC20V2(opts *bind.WatchOp // 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 (_GatewayV2 *GatewayV2Filterer) ParseExecutedWithERC20V2(log types.Log) (*GatewayV2ExecutedWithERC20V2, error) { - event := new(GatewayV2ExecutedWithERC20V2) - if err := _GatewayV2.contract.UnpackLog(event, "ExecutedWithERC20V2", log); err != nil { +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 } -// GatewayV2InitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayV2 contract. -type GatewayV2InitializedIterator struct { - Event *GatewayV2Initialized // Event containing the contract specifics and raw log +// 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 @@ -1059,7 +1059,7 @@ type GatewayV2InitializedIterator 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 *GatewayV2InitializedIterator) Next() bool { +func (it *GatewayUpgradeTestInitializedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1068,7 +1068,7 @@ func (it *GatewayV2InitializedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayV2Initialized) + it.Event = new(GatewayUpgradeTestInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1083,7 +1083,7 @@ func (it *GatewayV2InitializedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayV2Initialized) + it.Event = new(GatewayUpgradeTestInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1099,19 +1099,19 @@ func (it *GatewayV2InitializedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayV2InitializedIterator) Error() error { +func (it *GatewayUpgradeTestInitializedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayV2InitializedIterator) Close() error { +func (it *GatewayUpgradeTestInitializedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayV2Initialized represents a Initialized event raised by the GatewayV2 contract. -type GatewayV2Initialized struct { +// GatewayUpgradeTestInitialized represents a Initialized event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestInitialized struct { Version uint8 Raw types.Log // Blockchain specific contextual infos } @@ -1119,21 +1119,21 @@ type GatewayV2Initialized struct { // FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // // Solidity: event Initialized(uint8 version) -func (_GatewayV2 *GatewayV2Filterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayV2InitializedIterator, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayUpgradeTestInitializedIterator, error) { - logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "Initialized") + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Initialized") if err != nil { return nil, err } - return &GatewayV2InitializedIterator{contract: _GatewayV2.contract, event: "Initialized", logs: logs, sub: sub}, nil + 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 (_GatewayV2 *GatewayV2Filterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayV2Initialized) (event.Subscription, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestInitialized) (event.Subscription, error) { - logs, sub, err := _GatewayV2.contract.WatchLogs(opts, "Initialized") + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "Initialized") if err != nil { return nil, err } @@ -1143,8 +1143,8 @@ func (_GatewayV2 *GatewayV2Filterer) WatchInitialized(opts *bind.WatchOpts, sink select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayV2Initialized) - if err := _GatewayV2.contract.UnpackLog(event, "Initialized", log); err != nil { + event := new(GatewayUpgradeTestInitialized) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { return err } event.Raw = log @@ -1168,18 +1168,18 @@ func (_GatewayV2 *GatewayV2Filterer) WatchInitialized(opts *bind.WatchOpts, sink // ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // // Solidity: event Initialized(uint8 version) -func (_GatewayV2 *GatewayV2Filterer) ParseInitialized(log types.Log) (*GatewayV2Initialized, error) { - event := new(GatewayV2Initialized) - if err := _GatewayV2.contract.UnpackLog(event, "Initialized", log); err != nil { +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 } -// GatewayV2OwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayV2 contract. -type GatewayV2OwnershipTransferredIterator struct { - Event *GatewayV2OwnershipTransferred // Event containing the contract specifics and raw log +// 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 @@ -1193,7 +1193,7 @@ type GatewayV2OwnershipTransferredIterator 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 *GatewayV2OwnershipTransferredIterator) Next() bool { +func (it *GatewayUpgradeTestOwnershipTransferredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1202,7 +1202,7 @@ func (it *GatewayV2OwnershipTransferredIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayV2OwnershipTransferred) + it.Event = new(GatewayUpgradeTestOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1217,7 +1217,7 @@ func (it *GatewayV2OwnershipTransferredIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayV2OwnershipTransferred) + it.Event = new(GatewayUpgradeTestOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1233,19 +1233,19 @@ func (it *GatewayV2OwnershipTransferredIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayV2OwnershipTransferredIterator) Error() error { +func (it *GatewayUpgradeTestOwnershipTransferredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayV2OwnershipTransferredIterator) Close() error { +func (it *GatewayUpgradeTestOwnershipTransferredIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayV2OwnershipTransferred represents a OwnershipTransferred event raised by the GatewayV2 contract. -type GatewayV2OwnershipTransferred struct { +// 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 @@ -1254,7 +1254,7 @@ type GatewayV2OwnershipTransferred struct { // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayV2 *GatewayV2Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayV2OwnershipTransferredIterator, error) { +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayUpgradeTestOwnershipTransferredIterator, error) { var previousOwnerRule []interface{} for _, previousOwnerItem := range previousOwner { @@ -1265,17 +1265,17 @@ func (_GatewayV2 *GatewayV2Filterer) FilterOwnershipTransferred(opts *bind.Filte newOwnerRule = append(newOwnerRule, newOwnerItem) } - logs, sub, err := _GatewayV2.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } - return &GatewayV2OwnershipTransferredIterator{contract: _GatewayV2.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil + 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 (_GatewayV2 *GatewayV2Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayV2OwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { +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 { @@ -1286,7 +1286,7 @@ func (_GatewayV2 *GatewayV2Filterer) WatchOwnershipTransferred(opts *bind.WatchO newOwnerRule = append(newOwnerRule, newOwnerItem) } - logs, sub, err := _GatewayV2.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } @@ -1296,8 +1296,8 @@ func (_GatewayV2 *GatewayV2Filterer) WatchOwnershipTransferred(opts *bind.WatchO select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayV2OwnershipTransferred) - if err := _GatewayV2.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + event := new(GatewayUpgradeTestOwnershipTransferred) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return err } event.Raw = log @@ -1321,18 +1321,18 @@ func (_GatewayV2 *GatewayV2Filterer) WatchOwnershipTransferred(opts *bind.WatchO // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayV2 *GatewayV2Filterer) ParseOwnershipTransferred(log types.Log) (*GatewayV2OwnershipTransferred, error) { - event := new(GatewayV2OwnershipTransferred) - if err := _GatewayV2.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { +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 } -// GatewayV2UpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayV2 contract. -type GatewayV2UpgradedIterator struct { - Event *GatewayV2Upgraded // Event containing the contract specifics and raw log +// 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 @@ -1346,7 +1346,7 @@ type GatewayV2UpgradedIterator 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 *GatewayV2UpgradedIterator) Next() bool { +func (it *GatewayUpgradeTestUpgradedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1355,7 +1355,7 @@ func (it *GatewayV2UpgradedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayV2Upgraded) + it.Event = new(GatewayUpgradeTestUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1370,7 +1370,7 @@ func (it *GatewayV2UpgradedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayV2Upgraded) + it.Event = new(GatewayUpgradeTestUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1386,19 +1386,19 @@ func (it *GatewayV2UpgradedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayV2UpgradedIterator) Error() error { +func (it *GatewayUpgradeTestUpgradedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayV2UpgradedIterator) Close() error { +func (it *GatewayUpgradeTestUpgradedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayV2Upgraded represents a Upgraded event raised by the GatewayV2 contract. -type GatewayV2Upgraded struct { +// GatewayUpgradeTestUpgraded represents a Upgraded event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestUpgraded struct { Implementation common.Address Raw types.Log // Blockchain specific contextual infos } @@ -1406,31 +1406,31 @@ type GatewayV2Upgraded struct { // FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. // // Solidity: event Upgraded(address indexed implementation) -func (_GatewayV2 *GatewayV2Filterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayV2UpgradedIterator, error) { +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 := _GatewayV2.contract.FilterLogs(opts, "Upgraded", implementationRule) + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Upgraded", implementationRule) if err != nil { return nil, err } - return &GatewayV2UpgradedIterator{contract: _GatewayV2.contract, event: "Upgraded", logs: logs, sub: sub}, nil + 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 (_GatewayV2 *GatewayV2Filterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayV2Upgraded, implementation []common.Address) (event.Subscription, error) { +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 := _GatewayV2.contract.WatchLogs(opts, "Upgraded", implementationRule) + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "Upgraded", implementationRule) if err != nil { return nil, err } @@ -1440,8 +1440,8 @@ func (_GatewayV2 *GatewayV2Filterer) WatchUpgraded(opts *bind.WatchOpts, sink ch select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayV2Upgraded) - if err := _GatewayV2.contract.UnpackLog(event, "Upgraded", log); err != nil { + event := new(GatewayUpgradeTestUpgraded) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Upgraded", log); err != nil { return err } event.Raw = log @@ -1465,9 +1465,9 @@ func (_GatewayV2 *GatewayV2Filterer) WatchUpgraded(opts *bind.WatchOpts, sink ch // ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. // // Solidity: event Upgraded(address indexed implementation) -func (_GatewayV2 *GatewayV2Filterer) ParseUpgraded(log types.Log) (*GatewayV2Upgraded, error) { - event := new(GatewayV2Upgraded) - if err := _GatewayV2.contract.UnpackLog(event, "Upgraded", log); err != nil { +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 diff --git a/test/prototypes/GatewayUpgrade.spec.ts b/test/prototypes/GatewayUpgrade.spec.ts index cf731beb..5e25924b 100644 --- a/test/prototypes/GatewayUpgrade.spec.ts +++ b/test/prototypes/GatewayUpgrade.spec.ts @@ -38,7 +38,9 @@ describe("Gateway upgrade", 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"); + 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); From 39f2d096a66f118f520e1cebabd80650c4b55dca Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 24 Jun 2024 15:58:46 +0200 Subject: [PATCH 08/25] extend gateway with send functions --- contracts/prototypes/Gateway.sol | 29 ++- contracts/prototypes/GatewayUpgradeTest.sol | 35 +++- contracts/prototypes/interfaces.sol | 4 + test/prototypes/GatewayIntegration.spec.ts | 6 +- test/prototypes/GatewayUniswap.spec.ts | 5 +- test/prototypes/GatewayUpgrade.spec.ts | 6 +- .../contracts/prototypes/Gateway.ts | 151 ++++++++++++++- .../prototypes/GatewayUpgradeTest.ts | 173 ++++++++++++++++-- .../prototypes/interfaces.sol/IGateway.ts | 87 ++++++++- .../prototypes/ERC20CustodyNew__factory.ts | 2 +- .../prototypes/GatewayUpgradeTest__factory.ts | 120 +++++++++++- .../contracts/prototypes/Gateway__factory.ts | 118 +++++++++++- .../interfaces.sol/IGateway__factory.ts | 41 +++++ 13 files changed, 740 insertions(+), 37 deletions(-) diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol index 04d9d8fb..0d8851b8 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/Gateway.sol @@ -11,20 +11,27 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; // The contract doesn't hold any funds and should never have active allowances contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { error ExecutionFailed(); + error SendFailed(); + error InsufficientETHAmount(); 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 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(); + + tssAddress = _tssAddress; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -80,6 +87,26 @@ contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { return result; } + function sendERC20(bytes calldata recipient, address token, uint256 amount) external { + IERC20(token).transferFrom(msg.sender, address(custody), amount); + + emit SendERC20(recipient, token, amount); + } + + function send(bytes calldata recipient, uint256 amount) external payable { + if (msg.value < amount) { + revert InsufficientETHAmount(); + } + + (bool sent, ) = tssAddress.call{value: amount}(""); + + if (sent == false) { + revert SendFailed(); + } + + emit Send(recipient, amount); + } + function setCustody(address _custody) external { custody = _custody; } diff --git a/contracts/prototypes/GatewayUpgradeTest.sol b/contracts/prototypes/GatewayUpgradeTest.sol index 0a827536..7db92c97 100644 --- a/contracts/prototypes/GatewayUpgradeTest.sol +++ b/contracts/prototypes/GatewayUpgradeTest.sol @@ -7,25 +7,32 @@ 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 { error ExecutionFailed(); + error SendFailed(); + error InsufficientETHAmount(); 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(); + + tssAddress = _tssAddress; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -76,11 +83,31 @@ 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; } + function sendERC20(bytes calldata recipient, address token, uint256 amount) external { + IERC20(token).transferFrom(msg.sender, address(custody), amount); + + emit SendERC20(recipient, token, amount); + } + + function send(bytes calldata recipient, uint256 amount) external payable { + if (msg.value < amount) { + revert InsufficientETHAmount(); + } + + (bool sent, ) = tssAddress.call{value: amount}(""); + + if (sent == false) { + revert SendFailed(); + } + + emit Send(recipient, amount); + } + function setCustody(address _custody) external { custody = _custody; } diff --git a/contracts/prototypes/interfaces.sol b/contracts/prototypes/interfaces.sol index 58a474ae..122fda43 100644 --- a/contracts/prototypes/interfaces.sol +++ b/contracts/prototypes/interfaces.sol @@ -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/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index cb6c7bc1..69b8ba97 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -7,19 +7,19 @@ describe("Gateway and Receiver", function () { let gateway: Contract; let token: Contract; let custody: Contract; - let owner: any, destination: any; + 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("Gateway"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); - [owner, destination] = await ethers.getSigners(); + [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, [], { + gateway = await upgrades.deployProxy(Gateway, [tssAddress.address], { initializer: "initialize", kind: "uups", }); diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayUniswap.spec.ts index 7ee89a0c..a7b58487 100644 --- a/test/prototypes/GatewayUniswap.spec.ts +++ b/test/prototypes/GatewayUniswap.spec.ts @@ -23,9 +23,10 @@ describe("Uniswap Integration with Gateway", function () { let custody: ERC20CustodyNew; let gateway: Gateway; 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"); @@ -58,7 +59,7 @@ 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 upgrades.deployProxy(Gateway, [], { + gateway = (await upgrades.deployProxy(Gateway, [tssAddress.address], { initializer: "initialize", kind: "uups", })) as Gateway; diff --git a/test/prototypes/GatewayUpgrade.spec.ts b/test/prototypes/GatewayUpgrade.spec.ts index 5e25924b..ad9afcd8 100644 --- a/test/prototypes/GatewayUpgrade.spec.ts +++ b/test/prototypes/GatewayUpgrade.spec.ts @@ -7,19 +7,19 @@ describe("Gateway upgrade", function () { 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 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", }); 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/GatewayUpgradeTest.ts b/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts index d870814a..99a26238 100644 --- a/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts +++ b/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts @@ -33,12 +33,15 @@ export interface GatewayUpgradeTestInterface 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 GatewayUpgradeTestInterface extends utils.Interface { | "owner" | "proxiableUUID" | "renounceOwnership" + | "send" + | "sendERC20" | "setCustody" | "transferOwnership" + | "tssAddress" | "upgradeTo" | "upgradeToAndCall" ): FunctionFragment; @@ -74,7 +80,7 @@ export interface GatewayUpgradeTestInterface 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 GatewayUpgradeTestInterface 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 GatewayUpgradeTestInterface 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 GatewayUpgradeTestInterface 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", @@ -133,18 +158,22 @@ export interface GatewayUpgradeTestInterface extends utils.Interface { "AdminChanged(address,address)": EventFragment; "BeaconUpgraded(address)": EventFragment; "ExecutedV2(address,uint256,bytes)": EventFragment; - "ExecutedWithERC20V2(address,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: "ExecutedWithERC20V2"): 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; } @@ -181,19 +210,19 @@ export type ExecutedV2Event = TypedEvent< export type ExecutedV2EventFilter = TypedEventFilter; -export interface ExecutedWithERC20V2EventObject { +export interface ExecutedWithERC20EventObject { token: string; to: string; amount: BigNumber; data: string; } -export type ExecutedWithERC20V2Event = TypedEvent< +export type ExecutedWithERC20Event = TypedEvent< [string, string, BigNumber, string], - ExecutedWithERC20V2EventObject + ExecutedWithERC20EventObject >; -export type ExecutedWithERC20V2EventFilter = - TypedEventFilter; +export type ExecutedWithERC20EventFilter = + TypedEventFilter; export interface InitializedEventObject { version: number; @@ -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 GatewayUpgradeTest extends BaseContract { ): Promise; initialize( + _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -276,6 +326,19 @@ export interface GatewayUpgradeTest 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 GatewayUpgradeTest 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 GatewayUpgradeTest extends BaseContract { ): Promise; initialize( + _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -326,6 +392,19 @@ export interface GatewayUpgradeTest 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 GatewayUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + tssAddress(overrides?: CallOverrides): Promise; + upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -364,7 +445,10 @@ export interface GatewayUpgradeTest 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 GatewayUpgradeTest 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 GatewayUpgradeTest extends BaseContract { overrides?: CallOverrides ): Promise; + tssAddress(overrides?: CallOverrides): Promise; + upgradeTo( newImplementation: PromiseOrValue, overrides?: CallOverrides @@ -422,18 +521,18 @@ export interface GatewayUpgradeTest extends BaseContract { data?: null ): ExecutedV2EventFilter; - "ExecutedWithERC20V2(address,address,uint256,bytes)"( + "ExecutedWithERC20(address,address,uint256,bytes)"( token?: PromiseOrValue | null, to?: PromiseOrValue | null, amount?: null, data?: null - ): ExecutedWithERC20V2EventFilter; - ExecutedWithERC20V2( + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( token?: PromiseOrValue | null, to?: PromiseOrValue | null, amount?: null, data?: null - ): ExecutedWithERC20V2EventFilter; + ): ExecutedWithERC20EventFilter; "Initialized(uint8)"(version?: null): InitializedEventFilter; Initialized(version?: null): InitializedEventFilter; @@ -447,6 +546,20 @@ export interface GatewayUpgradeTest 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 GatewayUpgradeTest extends BaseContract { ): Promise; initialize( + _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -484,6 +598,19 @@ export interface GatewayUpgradeTest 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 GatewayUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + tssAddress(overrides?: CallOverrides): Promise; + upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -524,6 +653,7 @@ export interface GatewayUpgradeTest extends BaseContract { ): Promise; initialize( + _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -535,6 +665,19 @@ export interface GatewayUpgradeTest 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 GatewayUpgradeTest 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/interfaces.sol/IGateway.ts b/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts index 969095cb..8eb9509d 100644 --- a/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts +++ b/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts @@ -28,10 +28,16 @@ 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" + nameOrSignatureOrTopic: + | "execute" + | "executeWithERC20" + | "send" + | "sendERC20" ): FunctionFragment; encodeFunctionData( @@ -47,12 +53,26 @@ export interface IGatewayInterface 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: {}; } @@ -97,6 +117,19 @@ export interface IGateway 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( @@ -113,6 +146,19 @@ export interface IGateway 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, @@ -127,6 +173,19 @@ export interface IGateway 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: {}; @@ -145,6 +204,19 @@ export interface IGateway 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: { @@ -161,5 +233,18 @@ export interface IGateway 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/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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"; + "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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 index 09a34d87..74e2d223 100644 --- a/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts @@ -20,6 +20,16 @@ const _abi = [ name: "ExecutionFailed", type: "error", }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "SendFailed", + type: "error", + }, { anonymous: false, inputs: [ @@ -105,7 +115,7 @@ const _abi = [ type: "bytes", }, ], - name: "ExecutedWithERC20V2", + name: "ExecutedWithERC20", type: "event", }, { @@ -140,6 +150,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: [ @@ -225,7 +279,13 @@ const _abi = [ type: "function", }, { - inputs: [], + inputs: [ + { + internalType: "address", + name: "_tssAddress", + type: "address", + }, + ], name: "initialize", outputs: [], stateMutability: "nonpayable", @@ -264,6 +324,47 @@ 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: "token", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "sendERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [ { @@ -290,6 +391,19 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [], + name: "tssAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, { inputs: [ { @@ -324,7 +438,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayUpgradeTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts index 424b3e6f..7e29f6b7 100644 --- a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -20,6 +20,16 @@ const _abi = [ name: "ExecutionFailed", type: "error", }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "SendFailed", + type: "error", + }, { anonymous: false, inputs: [ @@ -140,6 +150,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: [ @@ -225,7 +279,13 @@ const _abi = [ type: "function", }, { - inputs: [], + inputs: [ + { + internalType: "address", + name: "_tssAddress", + type: "address", + }, + ], name: "initialize", outputs: [], stateMutability: "nonpayable", @@ -264,6 +324,47 @@ 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: "token", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "sendERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [ { @@ -290,6 +391,19 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [], + name: "tssAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, { inputs: [ { @@ -324,7 +438,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/interfaces.sol/IGateway__factory.ts b/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts index 20c69449..04e9ee3c 100644 --- a/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts @@ -68,6 +68,47 @@ 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 IGateway__factory { From 1085742395e4972309eff727b5a5188651f832aa Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 24 Jun 2024 16:46:14 +0200 Subject: [PATCH 09/25] generate --- .../erc20custodynew.sol/erc20custodynew.go | 2 +- .../prototypes/gateway.sol/gateway.go | 382 ++++++++++++++- .../gatewayupgradetest.go | 434 ++++++++++++++++-- .../prototypes/interfaces.sol/igateway.go | 44 +- 4 files changed, 806 insertions(+), 56 deletions(-) diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go index 84fac379..b45ba8b5 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\":\"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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", + 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 e0cb7151..a348969b 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\":[],\"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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", + 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\"}]", + Bin: "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", } // GatewayABI is the input ABI used to generate the binding from. @@ -295,6 +295,37 @@ func (_Gateway *GatewayCallerSession) ProxiableUUID() ([32]byte, error) { return _Gateway.Contract.ProxiableUUID(&_Gateway.CallOpts) } +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_Gateway *GatewayCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Gateway.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 (_Gateway *GatewaySession) TssAddress() (common.Address, error) { + return _Gateway.Contract.TssAddress(&_Gateway.CallOpts) +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_Gateway *GatewayCallerSession) TssAddress() (common.Address, error) { + return _Gateway.Contract.TssAddress(&_Gateway.CallOpts) +} + // Execute is a paid mutator transaction binding the contract method 0x1cff79cd. // // Solidity: function execute(address destination, bytes data) payable returns(bytes) @@ -337,25 +368,25 @@ 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. +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. // -// Solidity: function initialize() returns() -func (_Gateway *GatewayTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "initialize") +// Solidity: function initialize(address _tssAddress) returns() +func (_Gateway *GatewayTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "initialize", _tssAddress) } -// 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 (_Gateway *GatewaySession) Initialize() (*types.Transaction, error) { - return _Gateway.Contract.Initialize(&_Gateway.TransactOpts) +// Solidity: function initialize(address _tssAddress) returns() +func (_Gateway *GatewaySession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _Gateway.Contract.Initialize(&_Gateway.TransactOpts, _tssAddress) } -// 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 (_Gateway *GatewayTransactorSession) Initialize() (*types.Transaction, error) { - return _Gateway.Contract.Initialize(&_Gateway.TransactOpts) +// Solidity: function initialize(address _tssAddress) returns() +func (_Gateway *GatewayTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _Gateway.Contract.Initialize(&_Gateway.TransactOpts, _tssAddress) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. @@ -379,6 +410,48 @@ func (_Gateway *GatewayTransactorSession) RenounceOwnership() (*types.Transactio return _Gateway.Contract.RenounceOwnership(&_Gateway.TransactOpts) } +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_Gateway *GatewayTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _Gateway.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 (_Gateway *GatewaySession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _Gateway.Contract.Send(&_Gateway.TransactOpts, recipient, amount) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_Gateway *GatewayTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _Gateway.Contract.Send(&_Gateway.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 (_Gateway *GatewayTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Gateway.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 (_Gateway *GatewaySession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Gateway.Contract.SendERC20(&_Gateway.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 (_Gateway *GatewayTransactorSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _Gateway.Contract.SendERC20(&_Gateway.TransactOpts, recipient, token, amount) +} + // SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. // // Solidity: function setCustody(address _custody) returns() @@ -1330,6 +1403,287 @@ func (_Gateway *GatewayFilterer) ParseOwnershipTransferred(log types.Log) (*Gate return event, nil } +// GatewaySendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the Gateway contract. +type GatewaySendIterator struct { + Event *GatewaySend // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewaySendIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewaySend) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewaySend) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewaySendIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewaySendIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewaySend represents a Send event raised by the Gateway contract. +type GatewaySend 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 (_Gateway *GatewayFilterer) FilterSend(opts *bind.FilterOpts) (*GatewaySendIterator, error) { + + logs, sub, err := _Gateway.contract.FilterLogs(opts, "Send") + if err != nil { + return nil, err + } + return &GatewaySendIterator{contract: _Gateway.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 (_Gateway *GatewayFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewaySend) (event.Subscription, error) { + + logs, sub, err := _Gateway.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(GatewaySend) + if err := _Gateway.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 (_Gateway *GatewayFilterer) ParseSend(log types.Log) (*GatewaySend, error) { + event := new(GatewaySend) + if err := _Gateway.contract.UnpackLog(event, "Send", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewaySendERC20Iterator is returned from FilterSendERC20 and is used to iterate over the raw logs and unpacked data for SendERC20 events raised by the Gateway contract. +type GatewaySendERC20Iterator struct { + Event *GatewaySendERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewaySendERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewaySendERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewaySendERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewaySendERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewaySendERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewaySendERC20 represents a SendERC20 event raised by the Gateway contract. +type GatewaySendERC20 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 (_Gateway *GatewayFilterer) FilterSendERC20(opts *bind.FilterOpts, asset []common.Address) (*GatewaySendERC20Iterator, error) { + + var assetRule []interface{} + for _, assetItem := range asset { + assetRule = append(assetRule, assetItem) + } + + logs, sub, err := _Gateway.contract.FilterLogs(opts, "SendERC20", assetRule) + if err != nil { + return nil, err + } + return &GatewaySendERC20Iterator{contract: _Gateway.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 (_Gateway *GatewayFilterer) WatchSendERC20(opts *bind.WatchOpts, sink chan<- *GatewaySendERC20, asset []common.Address) (event.Subscription, error) { + + var assetRule []interface{} + for _, assetItem := range asset { + assetRule = append(assetRule, assetItem) + } + + logs, sub, err := _Gateway.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(GatewaySendERC20) + if err := _Gateway.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 (_Gateway *GatewayFilterer) ParseSendERC20(log types.Log) (*GatewaySendERC20, error) { + event := new(GatewaySendERC20) + if err := _Gateway.contract.UnpackLog(event, "SendERC20", 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 diff --git a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go index 8a542d44..e687e7b0 100644 --- a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go +++ b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go @@ -31,8 +31,8 @@ var ( // 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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", + 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\"}]", + Bin: "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", } // GatewayUpgradeTestABI is the input ABI used to generate the binding from. @@ -295,6 +295,37 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) ProxiableUUID() ([32 return _GatewayUpgradeTest.Contract.ProxiableUUID(&_GatewayUpgradeTest.CallOpts) } +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) TssAddress() (common.Address, error) { + return _GatewayUpgradeTest.Contract.TssAddress(&_GatewayUpgradeTest.CallOpts) +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) TssAddress() (common.Address, error) { + return _GatewayUpgradeTest.Contract.TssAddress(&_GatewayUpgradeTest.CallOpts) +} + // Execute is a paid mutator transaction binding the contract method 0x1cff79cd. // // Solidity: function execute(address destination, bytes data) payable returns(bytes) @@ -337,25 +368,25 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) ExecuteWithERC20 return _GatewayUpgradeTest.Contract.ExecuteWithERC20(&_GatewayUpgradeTest.TransactOpts, token, to, amount, data) } -// 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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "initialize") +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "initialize", _tssAddress) } -// 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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) Initialize() (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts) +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts, _tssAddress) } -// 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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Initialize() (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts) +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts, _tssAddress) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. @@ -379,6 +410,48 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) RenounceOwnershi return _GatewayUpgradeTest.Contract.RenounceOwnership(&_GatewayUpgradeTest.TransactOpts) } +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.Send(&_GatewayUpgradeTest.TransactOpts, recipient, amount) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.Send(&_GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.SendERC20(&_GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.SendERC20(&_GatewayUpgradeTest.TransactOpts, recipient, token, amount) +} + // SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. // // Solidity: function setCustody(address _custody) returns() @@ -888,9 +961,9 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseExecutedV2(log types 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 +// GatewayUpgradeTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestExecutedWithERC20Iterator struct { + Event *GatewayUpgradeTestExecutedWithERC20 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -904,7 +977,7 @@ type GatewayUpgradeTestExecutedWithERC20V2Iterator 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 *GatewayUpgradeTestExecutedWithERC20V2Iterator) Next() bool { +func (it *GatewayUpgradeTestExecutedWithERC20Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -913,7 +986,7 @@ func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedWithERC20V2) + it.Event = new(GatewayUpgradeTestExecutedWithERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -928,7 +1001,7 @@ func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedWithERC20V2) + it.Event = new(GatewayUpgradeTestExecutedWithERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -944,19 +1017,19 @@ func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Error() error { +func (it *GatewayUpgradeTestExecutedWithERC20Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Close() error { +func (it *GatewayUpgradeTestExecutedWithERC20Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestExecutedWithERC20V2 represents a ExecutedWithERC20V2 event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestExecutedWithERC20V2 struct { +// GatewayUpgradeTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestExecutedWithERC20 struct { Token common.Address To common.Address Amount *big.Int @@ -964,10 +1037,10 @@ type GatewayUpgradeTestExecutedWithERC20V2 struct { Raw types.Log // Blockchain specific contextual infos } -// FilterExecutedWithERC20V2 is a free log retrieval operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // -// 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) { +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayUpgradeTestExecutedWithERC20Iterator, error) { var tokenRule []interface{} for _, tokenItem := range token { @@ -978,17 +1051,17 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedWithERC20V2 toRule = append(toRule, toItem) } - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } - return &GatewayUpgradeTestExecutedWithERC20V2Iterator{contract: _GatewayUpgradeTest.contract, event: "ExecutedWithERC20V2", logs: logs, sub: sub}, nil + return &GatewayUpgradeTestExecutedWithERC20Iterator{contract: _GatewayUpgradeTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil } -// WatchExecutedWithERC20V2 is a free log subscription operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // -// 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) { +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { var tokenRule []interface{} for _, tokenItem := range token { @@ -999,7 +1072,7 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20V2( toRule = append(toRule, toItem) } - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } @@ -1009,8 +1082,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20V2( 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 { + event := new(GatewayUpgradeTestExecutedWithERC20) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return err } event.Raw = log @@ -1031,12 +1104,12 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20V2( }), nil } -// ParseExecutedWithERC20V2 is a log parse operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // -// 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 { +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayUpgradeTestExecutedWithERC20, error) { + event := new(GatewayUpgradeTestExecutedWithERC20) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return nil, err } event.Raw = log @@ -1330,6 +1403,287 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseOwnershipTransferred return event, nil } +// GatewayUpgradeTestSendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestSendIterator struct { + Event *GatewayUpgradeTestSend // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestSendIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestSend) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestSend) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestSendIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestSendIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestSend represents a Send event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestSend 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterSend(opts *bind.FilterOpts) (*GatewayUpgradeTestSendIterator, error) { + + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Send") + if err != nil { + return nil, err + } + return &GatewayUpgradeTestSendIterator{contract: _GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestSend) (event.Subscription, error) { + + logs, sub, err := _GatewayUpgradeTest.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(GatewayUpgradeTestSend) + if err := _GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseSend(log types.Log) (*GatewayUpgradeTestSend, error) { + event := new(GatewayUpgradeTestSend) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Send", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayUpgradeTestSendERC20Iterator is returned from FilterSendERC20 and is used to iterate over the raw logs and unpacked data for SendERC20 events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestSendERC20Iterator struct { + Event *GatewayUpgradeTestSendERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestSendERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestSendERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestSendERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestSendERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestSendERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestSendERC20 represents a SendERC20 event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestSendERC20 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterSendERC20(opts *bind.FilterOpts, asset []common.Address) (*GatewayUpgradeTestSendERC20Iterator, error) { + + var assetRule []interface{} + for _, assetItem := range asset { + assetRule = append(assetRule, assetItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "SendERC20", assetRule) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestSendERC20Iterator{contract: _GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchSendERC20(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestSendERC20, asset []common.Address) (event.Subscription, error) { + + var assetRule []interface{} + for _, assetItem := range asset { + assetRule = append(assetRule, assetItem) + } + + logs, sub, err := _GatewayUpgradeTest.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(GatewayUpgradeTestSendERC20) + if err := _GatewayUpgradeTest.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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseSendERC20(log types.Log) (*GatewayUpgradeTestSendERC20, error) { + event := new(GatewayUpgradeTestSendERC20) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "SendERC20", 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 diff --git a/pkg/contracts/prototypes/interfaces.sol/igateway.go b/pkg/contracts/prototypes/interfaces.sol/igateway.go index 34981e17..908b2546 100644 --- a/pkg/contracts/prototypes/interfaces.sol/igateway.go +++ b/pkg/contracts/prototypes/interfaces.sol/igateway.go @@ -31,7 +31,7 @@ var ( // 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\"}]", + 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\"}]", } // IGatewayABI is the input ABI used to generate the binding from. @@ -221,3 +221,45 @@ func (_IGateway *IGatewaySession) ExecuteWithERC20(token common.Address, to comm 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) } + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_IGateway *IGatewayTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _IGateway.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 (_IGateway *IGatewaySession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _IGateway.Contract.Send(&_IGateway.TransactOpts, recipient, amount) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_IGateway *IGatewayTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _IGateway.Contract.Send(&_IGateway.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 (_IGateway *IGatewayTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { + return _IGateway.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 (_IGateway *IGatewaySession) SendERC20(recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { + return _IGateway.Contract.SendERC20(&_IGateway.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 (_IGateway *IGatewayTransactorSession) SendERC20(recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { + return _IGateway.Contract.SendERC20(&_IGateway.TransactOpts, recipient, asset, amount) +} From b01d6ca93a69f4b7033b7352e647771fb9b5caea Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 24 Jun 2024 17:24:20 +0200 Subject: [PATCH 10/25] tests --- contracts/prototypes/Gateway.sol | 2 + contracts/prototypes/GatewayUpgradeTest.sol | 2 + test/prototypes/GatewayIntegration.spec.ts | 74 ++++++++++++++++++- .../prototypes/GatewayUpgradeTest__factory.ts | 2 +- .../contracts/prototypes/Gateway__factory.ts | 2 +- 5 files changed, 79 insertions(+), 3 deletions(-) diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol index 0d8851b8..7154b901 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/Gateway.sol @@ -87,12 +87,14 @@ contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { return result; } + // Tranfer 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); } + // Tranfer specified ETH amount to TSS address and emits event function send(bytes calldata recipient, uint256 amount) external payable { if (msg.value < amount) { revert InsufficientETHAmount(); diff --git a/contracts/prototypes/GatewayUpgradeTest.sol b/contracts/prototypes/GatewayUpgradeTest.sol index 7db92c97..4f35ab23 100644 --- a/contracts/prototypes/GatewayUpgradeTest.sol +++ b/contracts/prototypes/GatewayUpgradeTest.sol @@ -88,12 +88,14 @@ contract GatewayUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeabl return result; } + // Tranfer 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); } + // Tranfer specified ETH amount to TSS address and emits event function send(bytes calldata recipient, uint256 amount) external payable { if (msg.value < amount) { revert InsufficientETHAmount(); diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 69b8ba97..ec548f00 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -1,5 +1,5 @@ import { expect } from "chai"; -import { Contract } from "ethers"; +import { BigNumber, Contract } from "ethers"; import { ethers, upgrades } from "hardhat"; describe("Gateway and Receiver", function () { @@ -124,3 +124,75 @@ describe("Gateway and Receiver", function () { expect(allowance).to.equal(0); }); }); + +describe("Gateway evm 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("Gateway"); + 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 send 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.sendERC20(destination.address, token.address, amount); + await tx.wait(); + + 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, "SendERC20").withArgs(destination.address.toLowerCase(), token.address, amount); + }); + + it("should send eth to tss address and emit event", async function() { + const amount = ethers.utils.parseEther("100") as BigNumber; + + const tssAddressBalanceBefore = await ethers.provider.getBalance(tssAddress.address) as BigNumber; + + const tx = await gateway.send(destination.address, amount, { value: amount }); + await tx.wait(); + + const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); + expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); + + await expect(tx).to.emit(gateway, "Send").withArgs(destination.address.toLowerCase(), amount); + }); + + it("should fail to send to tss address if msg.value lower than amount", async function() { + const amount = ethers.utils.parseEther("100") as BigNumber; + + const tssAddressBalanceBefore = await ethers.provider.getBalance(tssAddress.address) as BigNumber; + + await expect(gateway.send(destination.address, amount, { value: amount.sub(1) })).to.be.revertedWith("InsufficientETHAmount") + + const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); + expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore); + }); +}); diff --git a/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts index 74e2d223..2a0bb549 100644 --- a/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts @@ -438,7 +438,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayUpgradeTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts index 7e29f6b7..a10ae000 100644 --- a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -438,7 +438,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayConstructorParams = | [signer?: Signer] From f2e6260ae0adf613219853cbc697fb0909597c72 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 24 Jun 2024 17:26:48 +0200 Subject: [PATCH 11/25] generate and lint --- .../prototypes/gateway.sol/gateway.go | 2 +- .../gatewayupgradetest.go | 2 +- test/prototypes/GatewayIntegration.spec.ts | 22 ++++++++++--------- 3 files changed, 14 insertions(+), 12 deletions(-) diff --git a/pkg/contracts/prototypes/gateway.sol/gateway.go b/pkg/contracts/prototypes/gateway.sol/gateway.go index a348969b..c6225fd9 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\":[],\"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\"}]", - Bin: "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", + Bin: "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c6126b5620002436000396000818161038701528181610416015281816105100152818161059f015261093b01526126b56000f3fe6080604052600436106100dd5760003560e01c80638da5cb5b1161007f578063c4d66de811610059578063c4d66de814610271578063cb0271ed1461029a578063dda79b75146102c3578063f2fde38b146102ee576100dd565b80638da5cb5b146102015780639372c4ab1461022c578063ae7a3a6f14610248576100dd565b80635131ab59116100bb5780635131ab591461015757806352d1902d146101945780635b112591146101bf578063715018a6146101ea576100dd565b80631cff79cd146100e25780633659cfe6146101125780634f1ef2861461013b575b600080fd5b6100fc60048036038101906100f791906118d1565b610317565b6040516101099190611f02565b60405180910390f35b34801561011e57600080fd5b506101396004803603810190610134919061181c565b610385565b005b61015560048036038101906101509190611931565b61050e565b005b34801561016357600080fd5b5061017e60048036038101906101799190611849565b61064b565b60405161018b9190611f02565b60405180910390f35b3480156101a057600080fd5b506101a9610937565b6040516101b69190611eb5565b60405180910390f35b3480156101cb57600080fd5b506101d46109f0565b6040516101e19190611e11565b60405180910390f35b3480156101f657600080fd5b506101ff610a16565b005b34801561020d57600080fd5b50610216610a2a565b6040516102239190611e11565b60405180910390f35b61024660048036038101906102419190611a5b565b610a54565b005b34801561025457600080fd5b5061026f600480360381019061026a919061181c565b610b9c565b005b34801561027d57600080fd5b506102986004803603810190610293919061181c565b610be0565b005b3480156102a657600080fd5b506102c160048036038101906102bc91906119e7565b610d68565b005b3480156102cf57600080fd5b506102d8610e72565b6040516102e59190611e11565b60405180910390f35b3480156102fa57600080fd5b506103156004803603810190610310919061181c565b610e98565b005b60606000610326858585610f1c565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f348686604051610372939291906120c1565b60405180910390a2809150509392505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610414576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161040b90611f81565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610453610fd3565b73ffffffffffffffffffffffffffffffffffffffff16146104a9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104a090611fa1565b60405180910390fd5b6104b28161102a565b61050b81600067ffffffffffffffff8111156104d1576104d0612282565b5b6040519080825280601f01601f1916602001820160405280156105035781602001600182028036833780820191505090505b506000611035565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16141561059d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161059490611f81565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166105dc610fd3565b73ffffffffffffffffffffffffffffffffffffffff1614610632576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161062990611fa1565b60405180910390fd5b61063b8261102a565b61064782826001611035565b5050565b60608573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b8152600401610688929190611e8c565b602060405180830381600087803b1580156106a257600080fd5b505af11580156106b6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106da919061198d565b5060006106e8868585610f1c565b90508673ffffffffffffffffffffffffffffffffffffffff1663095ea7b38760006040518363ffffffff1660e01b8152600401610726929190611e63565b602060405180830381600087803b15801561074057600080fd5b505af1158015610754573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610778919061198d565b5060008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016107b49190611e11565b60206040518083038186803b1580156107cc57600080fd5b505afa1580156107e0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108049190611abb565b905060008111156108c0578773ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff1660e01b815260040161086c929190611e8c565b602060405180830381600087803b15801561088657600080fd5b505af115801561089a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108be919061198d565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610921939291906120c1565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16146109c7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109be90611fc1565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610a1e6111b2565b610a286000611230565b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b80341015610a8e576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1682604051610ad690611dfc565b60006040518083038185875af1925050503d8060008114610b13576040519150601f19603f3d011682016040523d82523d6000602084013e610b18565b606091505b50509050600015158115151415610b5b576040517f81063e5100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7fa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58848484604051610b8e93929190611ed0565b60405180910390a150505050565b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610c115750600160008054906101000a900460ff1660ff16105b80610c3e5750610c20306112f6565b158015610c3d5750600160008054906101000a900460ff1660ff16145b5b610c7d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c7490612001565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610cba576001600060016101000a81548160ff0219169083151502179055505b610cc2611319565b610cca611372565b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508015610d645760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610d5b9190611f24565b60405180910390a15b5050565b8173ffffffffffffffffffffffffffffffffffffffff166323b872dd3360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b8152600401610dc793929190611e2c565b602060405180830381600087803b158015610de157600080fd5b505af1158015610df5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e19919061198d565b508173ffffffffffffffffffffffffffffffffffffffff167f35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af858584604051610e6493929190611ed0565b60405180910390a250505050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610ea06111b2565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610f10576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f0790611f61565b60405180910390fd5b610f1981611230565b50565b60606000808573ffffffffffffffffffffffffffffffffffffffff16348686604051610f49929190611dcc565b60006040518083038185875af1925050503d8060008114610f86576040519150601f19603f3d011682016040523d82523d6000602084013e610f8b565b606091505b509150915081610fc7576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006110017f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c3565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6110326111b2565b50565b6110617f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6113cd565b60000160009054906101000a900460ff161561108557611080836113d7565b6111ad565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110cb57600080fd5b505afa9250505080156110fc57506040513d601f19601f820116820180604052508101906110f991906119ba565b60015b61113b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161113290612021565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b81146111a0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161119790611fe1565b60405180910390fd5b506111ac838383611490565b5b505050565b6111ba6114bc565b73ffffffffffffffffffffffffffffffffffffffff166111d8610a2a565b73ffffffffffffffffffffffffffffffffffffffff161461122e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161122590612061565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611368576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161135f906120a1565b60405180910390fd5b6113706114c4565b565b600060019054906101000a900460ff166113c1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113b8906120a1565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6113e0816112f6565b61141f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161141690612041565b60405180910390fd5b8061144c7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c3565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b61149983611525565b6000825111806114a65750805b156114b7576114b58383611574565b505b505050565b600033905090565b600060019054906101000a900460ff16611513576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150a906120a1565b60405180910390fd5b61152361151e6114bc565b611230565b565b61152e816113d7565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b60606115998383604051806060016040528060278152602001612659602791396115a1565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516115cb9190611de5565b600060405180830381855af49150503d8060008114611606576040519150601f19603f3d011682016040523d82523d6000602084013e61160b565b606091505b509150915061161c86838387611627565b925050509392505050565b6060831561168a5760008351141561168257611642856112f6565b611681576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161167890612081565b60405180910390fd5b5b829050611695565b611694838361169d565b5b949350505050565b6000825111156116b05781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116e49190611f3f565b60405180910390fd5b60006117006116fb84612118565b6120f3565b90508281526020810184848401111561171c5761171b6122c0565b5b61172784828561220f565b509392505050565b60008135905061173e816125fc565b92915050565b60008151905061175381612613565b92915050565b6000815190506117688161262a565b92915050565b60008083601f840112611784576117836122b6565b5b8235905067ffffffffffffffff8111156117a1576117a06122b1565b5b6020830191508360018202830111156117bd576117bc6122bb565b5b9250929050565b600082601f8301126117d9576117d86122b6565b5b81356117e98482602086016116ed565b91505092915050565b60008135905061180181612641565b92915050565b60008151905061181681612641565b92915050565b600060208284031215611832576118316122ca565b5b60006118408482850161172f565b91505092915050565b600080600080600060808688031215611865576118646122ca565b5b60006118738882890161172f565b95505060206118848882890161172f565b9450506040611895888289016117f2565b935050606086013567ffffffffffffffff8111156118b6576118b56122c5565b5b6118c28882890161176e565b92509250509295509295909350565b6000806000604084860312156118ea576118e96122ca565b5b60006118f88682870161172f565b935050602084013567ffffffffffffffff811115611919576119186122c5565b5b6119258682870161176e565b92509250509250925092565b60008060408385031215611948576119476122ca565b5b60006119568582860161172f565b925050602083013567ffffffffffffffff811115611977576119766122c5565b5b611983858286016117c4565b9150509250929050565b6000602082840312156119a3576119a26122ca565b5b60006119b184828501611744565b91505092915050565b6000602082840312156119d0576119cf6122ca565b5b60006119de84828501611759565b91505092915050565b60008060008060608587031215611a0157611a006122ca565b5b600085013567ffffffffffffffff811115611a1f57611a1e6122c5565b5b611a2b8782880161176e565b94509450506020611a3e8782880161172f565b9250506040611a4f878288016117f2565b91505092959194509250565b600080600060408486031215611a7457611a736122ca565b5b600084013567ffffffffffffffff811115611a9257611a916122c5565b5b611a9e8682870161176e565b93509350506020611ab1868287016117f2565b9150509250925092565b600060208284031215611ad157611ad06122ca565b5b6000611adf84828501611807565b91505092915050565b611af18161218c565b82525050565b611b00816121aa565b82525050565b6000611b12838561215f565b9350611b1f83858461220f565b611b28836122cf565b840190509392505050565b6000611b3f8385612170565b9350611b4c83858461220f565b82840190509392505050565b6000611b6382612149565b611b6d818561215f565b9350611b7d81856020860161221e565b611b86816122cf565b840191505092915050565b6000611b9c82612149565b611ba68185612170565b9350611bb681856020860161221e565b80840191505092915050565b611bcb816121eb565b82525050565b611bda816121fd565b82525050565b6000611beb82612154565b611bf5818561217b565b9350611c0581856020860161221e565b611c0e816122cf565b840191505092915050565b6000611c2660268361217b565b9150611c31826122e0565b604082019050919050565b6000611c49602c8361217b565b9150611c548261232f565b604082019050919050565b6000611c6c602c8361217b565b9150611c778261237e565b604082019050919050565b6000611c8f60388361217b565b9150611c9a826123cd565b604082019050919050565b6000611cb260298361217b565b9150611cbd8261241c565b604082019050919050565b6000611cd5602e8361217b565b9150611ce08261246b565b604082019050919050565b6000611cf8602e8361217b565b9150611d03826124ba565b604082019050919050565b6000611d1b602d8361217b565b9150611d2682612509565b604082019050919050565b6000611d3e60208361217b565b9150611d4982612558565b602082019050919050565b6000611d61600083612170565b9150611d6c82612581565b600082019050919050565b6000611d84601d8361217b565b9150611d8f82612584565b602082019050919050565b6000611da7602b8361217b565b9150611db2826125ad565b604082019050919050565b611dc6816121d4565b82525050565b6000611dd9828486611b33565b91508190509392505050565b6000611df18284611b91565b915081905092915050565b6000611e0782611d54565b9150819050919050565b6000602082019050611e266000830184611ae8565b92915050565b6000606082019050611e416000830186611ae8565b611e4e6020830185611ae8565b611e5b6040830184611dbd565b949350505050565b6000604082019050611e786000830185611ae8565b611e856020830184611bc2565b9392505050565b6000604082019050611ea16000830185611ae8565b611eae6020830184611dbd565b9392505050565b6000602082019050611eca6000830184611af7565b92915050565b60006040820190508181036000830152611eeb818587611b06565b9050611efa6020830184611dbd565b949350505050565b60006020820190508181036000830152611f1c8184611b58565b905092915050565b6000602082019050611f396000830184611bd1565b92915050565b60006020820190508181036000830152611f598184611be0565b905092915050565b60006020820190508181036000830152611f7a81611c19565b9050919050565b60006020820190508181036000830152611f9a81611c3c565b9050919050565b60006020820190508181036000830152611fba81611c5f565b9050919050565b60006020820190508181036000830152611fda81611c82565b9050919050565b60006020820190508181036000830152611ffa81611ca5565b9050919050565b6000602082019050818103600083015261201a81611cc8565b9050919050565b6000602082019050818103600083015261203a81611ceb565b9050919050565b6000602082019050818103600083015261205a81611d0e565b9050919050565b6000602082019050818103600083015261207a81611d31565b9050919050565b6000602082019050818103600083015261209a81611d77565b9050919050565b600060208201905081810360008301526120ba81611d9a565b9050919050565b60006040820190506120d66000830186611dbd565b81810360208301526120e9818486611b06565b9050949350505050565b60006120fd61210e565b90506121098282612251565b919050565b6000604051905090565b600067ffffffffffffffff82111561213357612132612282565b5b61213c826122cf565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612197826121b4565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006121f6826121d4565b9050919050565b6000612208826121de565b9050919050565b82818337600083830152505050565b60005b8381101561223c578082015181840152602081019050612221565b8381111561224b576000848401525b50505050565b61225a826122cf565b810181811067ffffffffffffffff8211171561227957612278612282565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b6126058161218c565b811461261057600080fd5b50565b61261c8161219e565b811461262757600080fd5b50565b612633816121aa565b811461263e57600080fd5b50565b61264a816121d4565b811461265557600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a26469706673582212201e7cbd929e55cc43e5cdc66ed6524d47d8a9264ddfb58047ebf2e1dd71bfa92e64736f6c63430008070033", } // GatewayABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go index e687e7b0..0c3b8b15 100644 --- a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go +++ b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go @@ -32,7 +32,7 @@ var ( // GatewayUpgradeTestMetaData contains all meta data concerning the GatewayUpgradeTest contract. var GatewayUpgradeTestMetaData = &bind.MetaData{ 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\"}]", - Bin: "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", + Bin: "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", } // GatewayUpgradeTestABI is the input ABI used to generate the binding from. diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index ec548f00..6141aa9c 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -151,11 +151,11 @@ describe("Gateway evm inbound", function () { await token.mint(owner.address, ethers.utils.parseEther("1000")); }); - it("should send erc20 to custody and emit event", async function() { + it("should send 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); + expect(custodyBalanceBefore).to.equal(0); await token.approve(gateway.address, amount); @@ -163,7 +163,7 @@ describe("Gateway evm inbound", function () { await tx.wait(); const custodyBalanceAfter = await token.balanceOf(custody.address); - expect(custodyBalanceAfter).to.equal(amount); + expect(custodyBalanceAfter).to.equal(amount); const ownerBalanceAfter = await token.balanceOf(owner.address); expect(ownerBalanceAfter).to.equal(ethers.utils.parseEther("900")); @@ -171,28 +171,30 @@ describe("Gateway evm inbound", function () { await expect(tx).to.emit(gateway, "SendERC20").withArgs(destination.address.toLowerCase(), token.address, amount); }); - it("should send eth to tss address and emit event", async function() { + it("should send eth to tss address and emit event", async function () { const amount = ethers.utils.parseEther("100") as BigNumber; - const tssAddressBalanceBefore = await ethers.provider.getBalance(tssAddress.address) as BigNumber; + const tssAddressBalanceBefore = (await ethers.provider.getBalance(tssAddress.address)) as BigNumber; const tx = await gateway.send(destination.address, amount, { value: amount }); await tx.wait(); const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); - expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); + expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); await expect(tx).to.emit(gateway, "Send").withArgs(destination.address.toLowerCase(), amount); }); - it("should fail to send to tss address if msg.value lower than amount", async function() { + it("should fail to send to tss address if msg.value lower than amount", async function () { const amount = ethers.utils.parseEther("100") as BigNumber; - const tssAddressBalanceBefore = await ethers.provider.getBalance(tssAddress.address) as BigNumber; + const tssAddressBalanceBefore = (await ethers.provider.getBalance(tssAddress.address)) as BigNumber; - await expect(gateway.send(destination.address, amount, { value: amount.sub(1) })).to.be.revertedWith("InsufficientETHAmount") + await expect(gateway.send(destination.address, amount, { value: amount.sub(1) })).to.be.revertedWith( + "InsufficientETHAmount" + ); const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); - expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore); + expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore); }); }); From 023d9a6720a9cd36c12618b8f41b4bb426ce5e8a Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 24 Jun 2024 19:48:18 +0200 Subject: [PATCH 12/25] move current prototypes contracts to evm folder --- .../prototypes/{ => evm}/ERC20CustodyNew.sol | 0 contracts/prototypes/{ => evm}/Gateway.sol | 0 .../{ => evm}/GatewayUpgradeTest.sol | 0 contracts/prototypes/{ => evm}/Receiver.sol | 0 contracts/prototypes/{ => evm}/TestERC20.sol | 0 contracts/prototypes/{ => evm}/interfaces.sol | 0 .../erc20custodynew.sol/erc20custodynew.go | 2 +- .../{ => evm}/gateway.sol/gateway.go | 2 +- .../gatewayupgradetest.go | 2 +- .../{ => evm}/interfaces.sol/igateway.go | 0 .../{ => evm}/receiver.sol/receiver.go | 2 +- .../{ => evm}/testerc20.sol/testerc20.go | 2 +- .../prototypes/evm/ERC20CustodyNew.ts | 245 ++++++ .../contracts/prototypes/evm/Gateway.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 +++++++ .../prototypes/evm/interfaces.sol/index.ts | 4 + typechain-types/contracts/prototypes/index.ts | 9 +- .../evm/ERC20CustodyNew__factory.ts | 196 +++++ .../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 + .../evm/interfaces.sol/IGateway__factory.ts | 125 ++++ .../prototypes/evm/interfaces.sol/index.ts | 4 + .../factories/contracts/prototypes/index.ts | 7 +- typechain-types/index.ts | 24 +- 31 files changed, 4706 insertions(+), 30 deletions(-) rename contracts/prototypes/{ => evm}/ERC20CustodyNew.sol (100%) rename contracts/prototypes/{ => evm}/Gateway.sol (100%) rename contracts/prototypes/{ => evm}/GatewayUpgradeTest.sol (100%) rename contracts/prototypes/{ => evm}/Receiver.sol (100%) rename contracts/prototypes/{ => evm}/TestERC20.sol (100%) rename contracts/prototypes/{ => evm}/interfaces.sol (100%) rename pkg/contracts/prototypes/{ => evm}/erc20custodynew.sol/erc20custodynew.go (99%) rename pkg/contracts/prototypes/{ => evm}/gateway.sol/gateway.go (99%) rename pkg/contracts/prototypes/{ => evm}/gatewayupgradetest.sol/gatewayupgradetest.go (99%) rename pkg/contracts/prototypes/{ => evm}/interfaces.sol/igateway.go (100%) rename pkg/contracts/prototypes/{ => evm}/receiver.sol/receiver.go (99%) rename pkg/contracts/prototypes/{ => evm}/testerc20.sol/testerc20.go (99%) 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/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/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__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/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 100% rename from contracts/prototypes/ERC20CustodyNew.sol rename to contracts/prototypes/evm/ERC20CustodyNew.sol diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/evm/Gateway.sol similarity index 100% rename from contracts/prototypes/Gateway.sol rename to contracts/prototypes/evm/Gateway.sol diff --git a/contracts/prototypes/GatewayUpgradeTest.sol b/contracts/prototypes/evm/GatewayUpgradeTest.sol similarity index 100% rename from contracts/prototypes/GatewayUpgradeTest.sol rename to contracts/prototypes/evm/GatewayUpgradeTest.sol 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 100% rename from contracts/prototypes/interfaces.sol rename to contracts/prototypes/evm/interfaces.sol diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go similarity index 99% rename from pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go rename to pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go index b45ba8b5..099d3181 100644 --- a/pkg/contracts/prototypes/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\":\"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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", + 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/evm/gateway.sol/gateway.go similarity index 99% rename from pkg/contracts/prototypes/gateway.sol/gateway.go rename to pkg/contracts/prototypes/evm/gateway.sol/gateway.go index c6225fd9..3bbbf28d 100644 --- a/pkg/contracts/prototypes/gateway.sol/gateway.go +++ b/pkg/contracts/prototypes/evm/gateway.sol/gateway.go @@ -32,7 +32,7 @@ var ( // GatewayMetaData contains all meta data concerning the Gateway contract. var GatewayMetaData = &bind.MetaData{ 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\"}]", - Bin: "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c6126b5620002436000396000818161038701528181610416015281816105100152818161059f015261093b01526126b56000f3fe6080604052600436106100dd5760003560e01c80638da5cb5b1161007f578063c4d66de811610059578063c4d66de814610271578063cb0271ed1461029a578063dda79b75146102c3578063f2fde38b146102ee576100dd565b80638da5cb5b146102015780639372c4ab1461022c578063ae7a3a6f14610248576100dd565b80635131ab59116100bb5780635131ab591461015757806352d1902d146101945780635b112591146101bf578063715018a6146101ea576100dd565b80631cff79cd146100e25780633659cfe6146101125780634f1ef2861461013b575b600080fd5b6100fc60048036038101906100f791906118d1565b610317565b6040516101099190611f02565b60405180910390f35b34801561011e57600080fd5b506101396004803603810190610134919061181c565b610385565b005b61015560048036038101906101509190611931565b61050e565b005b34801561016357600080fd5b5061017e60048036038101906101799190611849565b61064b565b60405161018b9190611f02565b60405180910390f35b3480156101a057600080fd5b506101a9610937565b6040516101b69190611eb5565b60405180910390f35b3480156101cb57600080fd5b506101d46109f0565b6040516101e19190611e11565b60405180910390f35b3480156101f657600080fd5b506101ff610a16565b005b34801561020d57600080fd5b50610216610a2a565b6040516102239190611e11565b60405180910390f35b61024660048036038101906102419190611a5b565b610a54565b005b34801561025457600080fd5b5061026f600480360381019061026a919061181c565b610b9c565b005b34801561027d57600080fd5b506102986004803603810190610293919061181c565b610be0565b005b3480156102a657600080fd5b506102c160048036038101906102bc91906119e7565b610d68565b005b3480156102cf57600080fd5b506102d8610e72565b6040516102e59190611e11565b60405180910390f35b3480156102fa57600080fd5b506103156004803603810190610310919061181c565b610e98565b005b60606000610326858585610f1c565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f348686604051610372939291906120c1565b60405180910390a2809150509392505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610414576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161040b90611f81565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610453610fd3565b73ffffffffffffffffffffffffffffffffffffffff16146104a9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104a090611fa1565b60405180910390fd5b6104b28161102a565b61050b81600067ffffffffffffffff8111156104d1576104d0612282565b5b6040519080825280601f01601f1916602001820160405280156105035781602001600182028036833780820191505090505b506000611035565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16141561059d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161059490611f81565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166105dc610fd3565b73ffffffffffffffffffffffffffffffffffffffff1614610632576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161062990611fa1565b60405180910390fd5b61063b8261102a565b61064782826001611035565b5050565b60608573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b8152600401610688929190611e8c565b602060405180830381600087803b1580156106a257600080fd5b505af11580156106b6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106da919061198d565b5060006106e8868585610f1c565b90508673ffffffffffffffffffffffffffffffffffffffff1663095ea7b38760006040518363ffffffff1660e01b8152600401610726929190611e63565b602060405180830381600087803b15801561074057600080fd5b505af1158015610754573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610778919061198d565b5060008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016107b49190611e11565b60206040518083038186803b1580156107cc57600080fd5b505afa1580156107e0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108049190611abb565b905060008111156108c0578773ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff1660e01b815260040161086c929190611e8c565b602060405180830381600087803b15801561088657600080fd5b505af115801561089a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108be919061198d565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610921939291906120c1565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16146109c7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109be90611fc1565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610a1e6111b2565b610a286000611230565b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b80341015610a8e576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1682604051610ad690611dfc565b60006040518083038185875af1925050503d8060008114610b13576040519150601f19603f3d011682016040523d82523d6000602084013e610b18565b606091505b50509050600015158115151415610b5b576040517f81063e5100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7fa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58848484604051610b8e93929190611ed0565b60405180910390a150505050565b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610c115750600160008054906101000a900460ff1660ff16105b80610c3e5750610c20306112f6565b158015610c3d5750600160008054906101000a900460ff1660ff16145b5b610c7d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c7490612001565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610cba576001600060016101000a81548160ff0219169083151502179055505b610cc2611319565b610cca611372565b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508015610d645760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610d5b9190611f24565b60405180910390a15b5050565b8173ffffffffffffffffffffffffffffffffffffffff166323b872dd3360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b8152600401610dc793929190611e2c565b602060405180830381600087803b158015610de157600080fd5b505af1158015610df5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e19919061198d565b508173ffffffffffffffffffffffffffffffffffffffff167f35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af858584604051610e6493929190611ed0565b60405180910390a250505050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610ea06111b2565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610f10576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f0790611f61565b60405180910390fd5b610f1981611230565b50565b60606000808573ffffffffffffffffffffffffffffffffffffffff16348686604051610f49929190611dcc565b60006040518083038185875af1925050503d8060008114610f86576040519150601f19603f3d011682016040523d82523d6000602084013e610f8b565b606091505b509150915081610fc7576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006110017f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c3565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6110326111b2565b50565b6110617f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6113cd565b60000160009054906101000a900460ff161561108557611080836113d7565b6111ad565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110cb57600080fd5b505afa9250505080156110fc57506040513d601f19601f820116820180604052508101906110f991906119ba565b60015b61113b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161113290612021565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b81146111a0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161119790611fe1565b60405180910390fd5b506111ac838383611490565b5b505050565b6111ba6114bc565b73ffffffffffffffffffffffffffffffffffffffff166111d8610a2a565b73ffffffffffffffffffffffffffffffffffffffff161461122e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161122590612061565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611368576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161135f906120a1565b60405180910390fd5b6113706114c4565b565b600060019054906101000a900460ff166113c1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113b8906120a1565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6113e0816112f6565b61141f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161141690612041565b60405180910390fd5b8061144c7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c3565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b61149983611525565b6000825111806114a65750805b156114b7576114b58383611574565b505b505050565b600033905090565b600060019054906101000a900460ff16611513576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150a906120a1565b60405180910390fd5b61152361151e6114bc565b611230565b565b61152e816113d7565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b60606115998383604051806060016040528060278152602001612659602791396115a1565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516115cb9190611de5565b600060405180830381855af49150503d8060008114611606576040519150601f19603f3d011682016040523d82523d6000602084013e61160b565b606091505b509150915061161c86838387611627565b925050509392505050565b6060831561168a5760008351141561168257611642856112f6565b611681576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161167890612081565b60405180910390fd5b5b829050611695565b611694838361169d565b5b949350505050565b6000825111156116b05781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116e49190611f3f565b60405180910390fd5b60006117006116fb84612118565b6120f3565b90508281526020810184848401111561171c5761171b6122c0565b5b61172784828561220f565b509392505050565b60008135905061173e816125fc565b92915050565b60008151905061175381612613565b92915050565b6000815190506117688161262a565b92915050565b60008083601f840112611784576117836122b6565b5b8235905067ffffffffffffffff8111156117a1576117a06122b1565b5b6020830191508360018202830111156117bd576117bc6122bb565b5b9250929050565b600082601f8301126117d9576117d86122b6565b5b81356117e98482602086016116ed565b91505092915050565b60008135905061180181612641565b92915050565b60008151905061181681612641565b92915050565b600060208284031215611832576118316122ca565b5b60006118408482850161172f565b91505092915050565b600080600080600060808688031215611865576118646122ca565b5b60006118738882890161172f565b95505060206118848882890161172f565b9450506040611895888289016117f2565b935050606086013567ffffffffffffffff8111156118b6576118b56122c5565b5b6118c28882890161176e565b92509250509295509295909350565b6000806000604084860312156118ea576118e96122ca565b5b60006118f88682870161172f565b935050602084013567ffffffffffffffff811115611919576119186122c5565b5b6119258682870161176e565b92509250509250925092565b60008060408385031215611948576119476122ca565b5b60006119568582860161172f565b925050602083013567ffffffffffffffff811115611977576119766122c5565b5b611983858286016117c4565b9150509250929050565b6000602082840312156119a3576119a26122ca565b5b60006119b184828501611744565b91505092915050565b6000602082840312156119d0576119cf6122ca565b5b60006119de84828501611759565b91505092915050565b60008060008060608587031215611a0157611a006122ca565b5b600085013567ffffffffffffffff811115611a1f57611a1e6122c5565b5b611a2b8782880161176e565b94509450506020611a3e8782880161172f565b9250506040611a4f878288016117f2565b91505092959194509250565b600080600060408486031215611a7457611a736122ca565b5b600084013567ffffffffffffffff811115611a9257611a916122c5565b5b611a9e8682870161176e565b93509350506020611ab1868287016117f2565b9150509250925092565b600060208284031215611ad157611ad06122ca565b5b6000611adf84828501611807565b91505092915050565b611af18161218c565b82525050565b611b00816121aa565b82525050565b6000611b12838561215f565b9350611b1f83858461220f565b611b28836122cf565b840190509392505050565b6000611b3f8385612170565b9350611b4c83858461220f565b82840190509392505050565b6000611b6382612149565b611b6d818561215f565b9350611b7d81856020860161221e565b611b86816122cf565b840191505092915050565b6000611b9c82612149565b611ba68185612170565b9350611bb681856020860161221e565b80840191505092915050565b611bcb816121eb565b82525050565b611bda816121fd565b82525050565b6000611beb82612154565b611bf5818561217b565b9350611c0581856020860161221e565b611c0e816122cf565b840191505092915050565b6000611c2660268361217b565b9150611c31826122e0565b604082019050919050565b6000611c49602c8361217b565b9150611c548261232f565b604082019050919050565b6000611c6c602c8361217b565b9150611c778261237e565b604082019050919050565b6000611c8f60388361217b565b9150611c9a826123cd565b604082019050919050565b6000611cb260298361217b565b9150611cbd8261241c565b604082019050919050565b6000611cd5602e8361217b565b9150611ce08261246b565b604082019050919050565b6000611cf8602e8361217b565b9150611d03826124ba565b604082019050919050565b6000611d1b602d8361217b565b9150611d2682612509565b604082019050919050565b6000611d3e60208361217b565b9150611d4982612558565b602082019050919050565b6000611d61600083612170565b9150611d6c82612581565b600082019050919050565b6000611d84601d8361217b565b9150611d8f82612584565b602082019050919050565b6000611da7602b8361217b565b9150611db2826125ad565b604082019050919050565b611dc6816121d4565b82525050565b6000611dd9828486611b33565b91508190509392505050565b6000611df18284611b91565b915081905092915050565b6000611e0782611d54565b9150819050919050565b6000602082019050611e266000830184611ae8565b92915050565b6000606082019050611e416000830186611ae8565b611e4e6020830185611ae8565b611e5b6040830184611dbd565b949350505050565b6000604082019050611e786000830185611ae8565b611e856020830184611bc2565b9392505050565b6000604082019050611ea16000830185611ae8565b611eae6020830184611dbd565b9392505050565b6000602082019050611eca6000830184611af7565b92915050565b60006040820190508181036000830152611eeb818587611b06565b9050611efa6020830184611dbd565b949350505050565b60006020820190508181036000830152611f1c8184611b58565b905092915050565b6000602082019050611f396000830184611bd1565b92915050565b60006020820190508181036000830152611f598184611be0565b905092915050565b60006020820190508181036000830152611f7a81611c19565b9050919050565b60006020820190508181036000830152611f9a81611c3c565b9050919050565b60006020820190508181036000830152611fba81611c5f565b9050919050565b60006020820190508181036000830152611fda81611c82565b9050919050565b60006020820190508181036000830152611ffa81611ca5565b9050919050565b6000602082019050818103600083015261201a81611cc8565b9050919050565b6000602082019050818103600083015261203a81611ceb565b9050919050565b6000602082019050818103600083015261205a81611d0e565b9050919050565b6000602082019050818103600083015261207a81611d31565b9050919050565b6000602082019050818103600083015261209a81611d77565b9050919050565b600060208201905081810360008301526120ba81611d9a565b9050919050565b60006040820190506120d66000830186611dbd565b81810360208301526120e9818486611b06565b9050949350505050565b60006120fd61210e565b90506121098282612251565b919050565b6000604051905090565b600067ffffffffffffffff82111561213357612132612282565b5b61213c826122cf565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612197826121b4565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006121f6826121d4565b9050919050565b6000612208826121de565b9050919050565b82818337600083830152505050565b60005b8381101561223c578082015181840152602081019050612221565b8381111561224b576000848401525b50505050565b61225a826122cf565b810181811067ffffffffffffffff8211171561227957612278612282565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b6126058161218c565b811461261057600080fd5b50565b61261c8161219e565b811461262757600080fd5b50565b612633816121aa565b811461263e57600080fd5b50565b61264a816121d4565b811461265557600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a26469706673582212201e7cbd929e55cc43e5cdc66ed6524d47d8a9264ddfb58047ebf2e1dd71bfa92e64736f6c63430008070033", + Bin: "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", } // GatewayABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go b/pkg/contracts/prototypes/evm/gatewayupgradetest.sol/gatewayupgradetest.go similarity index 99% rename from pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go rename to pkg/contracts/prototypes/evm/gatewayupgradetest.sol/gatewayupgradetest.go index 0c3b8b15..25c7a3f8 100644 --- a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go +++ b/pkg/contracts/prototypes/evm/gatewayupgradetest.sol/gatewayupgradetest.go @@ -32,7 +32,7 @@ var ( // GatewayUpgradeTestMetaData contains all meta data concerning the GatewayUpgradeTest contract. var GatewayUpgradeTestMetaData = &bind.MetaData{ 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\"}]", - Bin: "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", + Bin: "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", } // GatewayUpgradeTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/interfaces.sol/igateway.go b/pkg/contracts/prototypes/evm/interfaces.sol/igateway.go similarity index 100% rename from pkg/contracts/prototypes/interfaces.sol/igateway.go rename to pkg/contracts/prototypes/evm/interfaces.sol/igateway.go 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/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/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..8e3200c1 --- /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 { 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/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/index.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts new file mode 100644 index 00000000..878cfe66 --- /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 { IGateway } from "./IGateway"; 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/evm/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts new file mode 100644 index 00000000..3446cb5f --- /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 IGateway", + 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/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..6fb60d1c --- /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 { 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/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..d3a5c88a --- /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 { IGateway__factory } from "./IGateway__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/index.ts b/typechain-types/index.ts index 6f13ad23..90484cc7 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 { Gateway } from "./contracts/prototypes/evm/Gateway"; +export { Gateway__factory } from "./factories/contracts/prototypes/evm/Gateway__factory"; +export type { GatewayUpgradeTest } from "./contracts/prototypes/evm/GatewayUpgradeTest"; +export { GatewayUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayUpgradeTest__factory"; +export type { IGateway } from "./contracts/prototypes/evm/interfaces.sol/IGateway"; +export { IGateway__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGateway__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 20da62a918541444af24f532f80ef89c38e94ee6 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 24 Jun 2024 20:03:50 +0200 Subject: [PATCH 13/25] renamings --- contracts/prototypes/evm/ERC20CustodyNew.sol | 4 +- .../evm/{Gateway.sol => GatewayEVM.sol} | 12 +- ...radeTest.sol => GatewayEVMUpgradeTest.sol} | 2 +- contracts/prototypes/evm/interfaces.sol | 2 +- .../erc20custodynew.sol/erc20custodynew.go | 4 +- .../prototypes/evm/gateway.sol/gateway.go | 1829 ---------------- .../evm/gatewayevm.sol/gatewayevm.go | 1831 +++++++++++++++++ .../gatewayevmupgradetest.go} | 686 +++--- .../prototypes/evm/interfaces.sol/igateway.go | 265 --- .../evm/interfaces.sol/igatewayevm.go | 265 +++ test/prototypes/GatewayIntegration.spec.ts | 14 +- test/prototypes/GatewayUniswap.spec.ts | 10 +- test/prototypes/GatewayUpgrade.spec.ts | 8 +- .../contracts/prototypes/evm/GatewayEVM.ts | 715 +++++++ .../prototypes/evm/GatewayEVMUpgradeTest.ts | 704 +++++++ .../contracts/prototypes/evm/index.ts | 4 +- .../evm/interfaces.sol/IGatewayEVM.ts | 250 +++ .../prototypes/evm/interfaces.sol/index.ts | 2 +- .../evm/ERC20CustodyNew__factory.ts | 4 +- .../evm/GatewayEVMUpgradeTest__factory.ts | 492 +++++ .../prototypes/evm/GatewayEVM__factory.ts | 500 +++++ .../contracts/prototypes/evm/index.ts | 4 +- .../interfaces.sol/IGatewayEVM__factory.ts | 125 ++ .../prototypes/evm/interfaces.sol/index.ts | 2 +- typechain-types/hardhat.d.ts | 24 +- typechain-types/index.ts | 12 +- 26 files changed, 5280 insertions(+), 2490 deletions(-) rename contracts/prototypes/evm/{Gateway.sol => GatewayEVM.sol} (89%) rename contracts/prototypes/evm/{GatewayUpgradeTest.sol => GatewayEVMUpgradeTest.sol} (97%) delete mode 100644 pkg/contracts/prototypes/evm/gateway.sol/gateway.go create mode 100644 pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go rename pkg/contracts/prototypes/evm/{gatewayupgradetest.sol/gatewayupgradetest.go => gatewayevmupgradetest.sol/gatewayevmupgradetest.go} (66%) delete mode 100644 pkg/contracts/prototypes/evm/interfaces.sol/igateway.go create mode 100644 pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go 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/interfaces.sol/IGatewayEVM.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/interfaces.sol/IGatewayEVM__factory.ts diff --git a/contracts/prototypes/evm/ERC20CustodyNew.sol b/contracts/prototypes/evm/ERC20CustodyNew.sol index 803eec8e..2dbf54a4 100644 --- a/contracts/prototypes/evm/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/evm/Gateway.sol b/contracts/prototypes/evm/GatewayEVM.sol similarity index 89% rename from contracts/prototypes/evm/Gateway.sol rename to contracts/prototypes/evm/GatewayEVM.sol index 7154b901..aa7a0780 100644 --- a/contracts/prototypes/evm/Gateway.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -7,9 +7,9 @@ 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 SendFailed(); error InsufficientETHAmount(); @@ -19,8 +19,8 @@ contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { event Executed(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); + event SendERC20(address sender, bytes recipient, address indexed asset, uint256 amount); + event Send(address sender, bytes recipient, uint256 amount); /// @custom:oz-upgrades-unsafe-allow constructor constructor() { @@ -91,7 +91,7 @@ contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { function sendERC20(bytes calldata recipient, address token, uint256 amount) external { IERC20(token).transferFrom(msg.sender, address(custody), amount); - emit SendERC20(recipient, token, amount); + emit SendERC20(msg.sender, recipient, token, amount); } // Tranfer specified ETH amount to TSS address and emits event @@ -106,7 +106,7 @@ contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { revert SendFailed(); } - emit Send(recipient, amount); + emit Send(msg.sender, recipient, amount); } function setCustody(address _custody) external { diff --git a/contracts/prototypes/evm/GatewayUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol similarity index 97% rename from contracts/prototypes/evm/GatewayUpgradeTest.sol rename to contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index 4f35ab23..81dc6a4e 100644 --- a/contracts/prototypes/evm/GatewayUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -10,7 +10,7 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.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 GatewayUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { error ExecutionFailed(); error SendFailed(); error InsufficientETHAmount(); diff --git a/contracts/prototypes/evm/interfaces.sol b/contracts/prototypes/evm/interfaces.sol index 122fda43..38d006c8 100644 --- a/contracts/prototypes/evm/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, diff --git a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go index 099d3181..9f42a416 100644 --- a/pkg/contracts/prototypes/evm/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/gateway.sol/gateway.go b/pkg/contracts/prototypes/evm/gateway.sol/gateway.go deleted file mode 100644 index 3bbbf28d..00000000 --- a/pkg/contracts/prototypes/evm/gateway.sol/gateway.go +++ /dev/null @@ -1,1829 +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\"},{\"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\"}]", - 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) -} - -// TssAddress is a free data retrieval call binding the contract method 0x5b112591. -// -// Solidity: function tssAddress() view returns(address) -func (_Gateway *GatewayCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _Gateway.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 (_Gateway *GatewaySession) TssAddress() (common.Address, error) { - return _Gateway.Contract.TssAddress(&_Gateway.CallOpts) -} - -// TssAddress is a free data retrieval call binding the contract method 0x5b112591. -// -// Solidity: function tssAddress() view returns(address) -func (_Gateway *GatewayCallerSession) TssAddress() (common.Address, error) { - return _Gateway.Contract.TssAddress(&_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 0xc4d66de8. -// -// Solidity: function initialize(address _tssAddress) returns() -func (_Gateway *GatewayTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "initialize", _tssAddress) -} - -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. -// -// Solidity: function initialize(address _tssAddress) returns() -func (_Gateway *GatewaySession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _Gateway.Contract.Initialize(&_Gateway.TransactOpts, _tssAddress) -} - -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. -// -// Solidity: function initialize(address _tssAddress) returns() -func (_Gateway *GatewayTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _Gateway.Contract.Initialize(&_Gateway.TransactOpts, _tssAddress) -} - -// 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) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_Gateway *GatewayTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _Gateway.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 (_Gateway *GatewaySession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _Gateway.Contract.Send(&_Gateway.TransactOpts, recipient, amount) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_Gateway *GatewayTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _Gateway.Contract.Send(&_Gateway.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 (_Gateway *GatewayTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _Gateway.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 (_Gateway *GatewaySession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _Gateway.Contract.SendERC20(&_Gateway.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 (_Gateway *GatewayTransactorSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _Gateway.Contract.SendERC20(&_Gateway.TransactOpts, recipient, token, amount) -} - -// 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 -} - -// GatewaySendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the Gateway contract. -type GatewaySendIterator struct { - Event *GatewaySend // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewaySendIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewaySend) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewaySend) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewaySendIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewaySendIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewaySend represents a Send event raised by the Gateway contract. -type GatewaySend 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 (_Gateway *GatewayFilterer) FilterSend(opts *bind.FilterOpts) (*GatewaySendIterator, error) { - - logs, sub, err := _Gateway.contract.FilterLogs(opts, "Send") - if err != nil { - return nil, err - } - return &GatewaySendIterator{contract: _Gateway.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 (_Gateway *GatewayFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewaySend) (event.Subscription, error) { - - logs, sub, err := _Gateway.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(GatewaySend) - if err := _Gateway.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 (_Gateway *GatewayFilterer) ParseSend(log types.Log) (*GatewaySend, error) { - event := new(GatewaySend) - if err := _Gateway.contract.UnpackLog(event, "Send", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewaySendERC20Iterator is returned from FilterSendERC20 and is used to iterate over the raw logs and unpacked data for SendERC20 events raised by the Gateway contract. -type GatewaySendERC20Iterator struct { - Event *GatewaySendERC20 // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewaySendERC20Iterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewaySendERC20) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewaySendERC20) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewaySendERC20Iterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewaySendERC20Iterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewaySendERC20 represents a SendERC20 event raised by the Gateway contract. -type GatewaySendERC20 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 (_Gateway *GatewayFilterer) FilterSendERC20(opts *bind.FilterOpts, asset []common.Address) (*GatewaySendERC20Iterator, error) { - - var assetRule []interface{} - for _, assetItem := range asset { - assetRule = append(assetRule, assetItem) - } - - logs, sub, err := _Gateway.contract.FilterLogs(opts, "SendERC20", assetRule) - if err != nil { - return nil, err - } - return &GatewaySendERC20Iterator{contract: _Gateway.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 (_Gateway *GatewayFilterer) WatchSendERC20(opts *bind.WatchOpts, sink chan<- *GatewaySendERC20, asset []common.Address) (event.Subscription, error) { - - var assetRule []interface{} - for _, assetItem := range asset { - assetRule = append(assetRule, assetItem) - } - - logs, sub, err := _Gateway.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(GatewaySendERC20) - if err := _Gateway.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 (_Gateway *GatewayFilterer) ParseSendERC20(log types.Log) (*GatewaySendERC20, error) { - event := new(GatewaySendERC20) - if err := _Gateway.contract.UnpackLog(event, "SendERC20", 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/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go new file mode 100644 index 00000000..7536d9b2 --- /dev/null +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -0,0 +1,1831 @@ +// 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\":\"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\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"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\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"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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", +} + +// 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) +} + +// 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) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_GatewayEVM *GatewayEVMTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVM.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 (_GatewayEVM *GatewayEVMSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVM.Contract.Send(&_GatewayEVM.TransactOpts, recipient, amount) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_GatewayEVM *GatewayEVMTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVM.Contract.Send(&_GatewayEVM.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 (_GatewayEVM *GatewayEVMTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVM.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 (_GatewayEVM *GatewayEVMSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVM.Contract.SendERC20(&_GatewayEVM.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 (_GatewayEVM *GatewayEVMTransactorSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVM.Contract.SendERC20(&_GatewayEVM.TransactOpts, recipient, token, amount) +} + +// 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 +} + +// 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 +} + +// GatewayEVMSendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the GatewayEVM contract. +type GatewayEVMSendIterator struct { + Event *GatewayEVMSend // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMSendIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMSend) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMSend) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMSendIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMSendIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMSend represents a Send event raised by the GatewayEVM contract. +type GatewayEVMSend struct { + Sender common.Address + Recipient []byte + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSend is a free log retrieval operation binding the contract event 0x84583322b159855a8990ae36b9708ebcb1d1c7fdccf3cd41e19e4f65f00bb2b6. +// +// Solidity: event Send(address sender, bytes recipient, uint256 amount) +func (_GatewayEVM *GatewayEVMFilterer) FilterSend(opts *bind.FilterOpts) (*GatewayEVMSendIterator, error) { + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Send") + if err != nil { + return nil, err + } + return &GatewayEVMSendIterator{contract: _GatewayEVM.contract, event: "Send", logs: logs, sub: sub}, nil +} + +// WatchSend is a free log subscription operation binding the contract event 0x84583322b159855a8990ae36b9708ebcb1d1c7fdccf3cd41e19e4f65f00bb2b6. +// +// Solidity: event Send(address sender, bytes recipient, uint256 amount) +func (_GatewayEVM *GatewayEVMFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewayEVMSend) (event.Subscription, error) { + + logs, sub, err := _GatewayEVM.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(GatewayEVMSend) + if err := _GatewayEVM.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 0x84583322b159855a8990ae36b9708ebcb1d1c7fdccf3cd41e19e4f65f00bb2b6. +// +// Solidity: event Send(address sender, bytes recipient, uint256 amount) +func (_GatewayEVM *GatewayEVMFilterer) ParseSend(log types.Log) (*GatewayEVMSend, error) { + event := new(GatewayEVMSend) + if err := _GatewayEVM.contract.UnpackLog(event, "Send", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMSendERC20Iterator is returned from FilterSendERC20 and is used to iterate over the raw logs and unpacked data for SendERC20 events raised by the GatewayEVM contract. +type GatewayEVMSendERC20Iterator struct { + Event *GatewayEVMSendERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMSendERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMSendERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMSendERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMSendERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMSendERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMSendERC20 represents a SendERC20 event raised by the GatewayEVM contract. +type GatewayEVMSendERC20 struct { + Sender common.Address + 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 0xf31c5882db91f6b727bb3fe49d02ca7e0e036d99bd5f6bb64cb0c8d9f74f9911. +// +// Solidity: event SendERC20(address sender, bytes recipient, address indexed asset, uint256 amount) +func (_GatewayEVM *GatewayEVMFilterer) FilterSendERC20(opts *bind.FilterOpts, asset []common.Address) (*GatewayEVMSendERC20Iterator, error) { + + var assetRule []interface{} + for _, assetItem := range asset { + assetRule = append(assetRule, assetItem) + } + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "SendERC20", assetRule) + if err != nil { + return nil, err + } + return &GatewayEVMSendERC20Iterator{contract: _GatewayEVM.contract, event: "SendERC20", logs: logs, sub: sub}, nil +} + +// WatchSendERC20 is a free log subscription operation binding the contract event 0xf31c5882db91f6b727bb3fe49d02ca7e0e036d99bd5f6bb64cb0c8d9f74f9911. +// +// Solidity: event SendERC20(address sender, bytes recipient, address indexed asset, uint256 amount) +func (_GatewayEVM *GatewayEVMFilterer) WatchSendERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMSendERC20, asset []common.Address) (event.Subscription, error) { + + var assetRule []interface{} + for _, assetItem := range asset { + assetRule = append(assetRule, assetItem) + } + + logs, sub, err := _GatewayEVM.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(GatewayEVMSendERC20) + if err := _GatewayEVM.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 0xf31c5882db91f6b727bb3fe49d02ca7e0e036d99bd5f6bb64cb0c8d9f74f9911. +// +// Solidity: event SendERC20(address sender, bytes recipient, address indexed asset, uint256 amount) +func (_GatewayEVM *GatewayEVMFilterer) ParseSendERC20(log types.Log) (*GatewayEVMSendERC20, error) { + event := new(GatewayEVMSendERC20) + if err := _GatewayEVM.contract.UnpackLog(event, "SendERC20", 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/gatewayupgradetest.sol/gatewayupgradetest.go b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go similarity index 66% rename from pkg/contracts/prototypes/evm/gatewayupgradetest.sol/gatewayupgradetest.go rename to pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go index 25c7a3f8..d5f68a44 100644 --- a/pkg/contracts/prototypes/evm/gatewayupgradetest.sol/gatewayupgradetest.go +++ b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package gatewayupgradetest +package gatewayevmupgradetest import ( "errors" @@ -29,23 +29,23 @@ var ( _ = abi.ConvertType ) -// GatewayUpgradeTestMetaData contains all meta data concerning the GatewayUpgradeTest contract. -var GatewayUpgradeTestMetaData = &bind.MetaData{ +// 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\"},{\"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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", + 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 +// GatewayEVMUpgradeTestABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayEVMUpgradeTestMetaData.ABI instead. +var GatewayEVMUpgradeTestABI = GatewayEVMUpgradeTestMetaData.ABI -// GatewayUpgradeTestBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use GatewayUpgradeTestMetaData.Bin instead. -var GatewayUpgradeTestBin = GatewayUpgradeTestMetaData.Bin +// GatewayEVMUpgradeTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayEVMUpgradeTestMetaData.Bin instead. +var GatewayEVMUpgradeTestBin = GatewayEVMUpgradeTestMetaData.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() +// 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 } @@ -53,111 +53,111 @@ func DeployGatewayUpgradeTest(auth *bind.TransactOpts, backend bind.ContractBack return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(GatewayUpgradeTestBin), backend) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(GatewayEVMUpgradeTestBin), 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 + return address, tx, &GatewayEVMUpgradeTest{GatewayEVMUpgradeTestCaller: GatewayEVMUpgradeTestCaller{contract: contract}, GatewayEVMUpgradeTestTransactor: GatewayEVMUpgradeTestTransactor{contract: contract}, GatewayEVMUpgradeTestFilterer: GatewayEVMUpgradeTestFilterer{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 +// 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 } -// GatewayUpgradeTestCaller is an auto generated read-only Go binding around an Ethereum contract. -type GatewayUpgradeTestCaller struct { +// 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 } -// GatewayUpgradeTestTransactor is an auto generated write-only Go binding around an Ethereum contract. -type GatewayUpgradeTestTransactor struct { +// 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 } -// GatewayUpgradeTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type GatewayUpgradeTestFilterer struct { +// 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 } -// GatewayUpgradeTestSession is an auto generated Go binding around an Ethereum contract, +// GatewayEVMUpgradeTestSession 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 +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 } -// GatewayUpgradeTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// GatewayEVMUpgradeTestCallerSession 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 +type GatewayEVMUpgradeTestCallerSession struct { + Contract *GatewayEVMUpgradeTestCaller // 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, +// GatewayEVMUpgradeTestTransactorSession 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 +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 } -// 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 +// 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 } -// 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 +// 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 } -// 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 +// 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 } -// 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) +// 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 &GatewayUpgradeTest{GatewayUpgradeTestCaller: GatewayUpgradeTestCaller{contract: contract}, GatewayUpgradeTestTransactor: GatewayUpgradeTestTransactor{contract: contract}, GatewayUpgradeTestFilterer: GatewayUpgradeTestFilterer{contract: contract}}, nil + return &GatewayEVMUpgradeTest{GatewayEVMUpgradeTestCaller: GatewayEVMUpgradeTestCaller{contract: contract}, GatewayEVMUpgradeTestTransactor: GatewayEVMUpgradeTestTransactor{contract: contract}, GatewayEVMUpgradeTestFilterer: GatewayEVMUpgradeTestFilterer{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) +// 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 &GatewayUpgradeTestCaller{contract: contract}, nil + return &GatewayEVMUpgradeTestCaller{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) +// 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 &GatewayUpgradeTestTransactor{contract: contract}, nil + return &GatewayEVMUpgradeTestTransactor{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) +// 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 &GatewayUpgradeTestFilterer{contract: contract}, nil + return &GatewayEVMUpgradeTestFilterer{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() +// 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 } @@ -168,46 +168,46 @@ func bindGatewayUpgradeTest(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 (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayUpgradeTest.Contract.GatewayUpgradeTestCaller.contract.Call(opts, result, method, params...) +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 (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.GatewayUpgradeTestTransactor.contract.Transfer(opts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.GatewayUpgradeTestTransactor.contract.Transact(opts, method, params...) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayUpgradeTest.Contract.contract.Call(opts, result, method, params...) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.contract.Transfer(opts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.contract.Transact(opts, method, params...) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Custody(opts *bind.CallOpts) (common.Address, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) Custody(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayUpgradeTest.contract.Call(opts, &out, "custody") + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "custody") if err != nil { return *new(common.Address), err @@ -222,23 +222,23 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Custody(opts *bind.CallOpts // 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) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) Custody() (common.Address, error) { - return _GatewayUpgradeTest.Contract.Custody(&_GatewayUpgradeTest.CallOpts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Owner(opts *bind.CallOpts) (common.Address, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) Owner(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayUpgradeTest.contract.Call(opts, &out, "owner") + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "owner") if err != nil { return *new(common.Address), err @@ -253,23 +253,23 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Owner(opts *bind.CallOpts) // 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) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) Owner() (common.Address, error) { - return _GatewayUpgradeTest.Contract.Owner(&_GatewayUpgradeTest.CallOpts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { var out []interface{} - err := _GatewayUpgradeTest.contract.Call(opts, &out, "proxiableUUID") + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "proxiableUUID") if err != nil { return *new([32]byte), err @@ -284,23 +284,23 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) ProxiableUUID(opts *bind.Ca // 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) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) ProxiableUUID() ([32]byte, error) { - return _GatewayUpgradeTest.Contract.ProxiableUUID(&_GatewayUpgradeTest.CallOpts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayUpgradeTest.contract.Call(opts, &out, "tssAddress") + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "tssAddress") if err != nil { return *new(common.Address), err @@ -315,230 +315,230 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) TssAddress(opts *bind.CallO // TssAddress is a free data retrieval call binding the contract method 0x5b112591. // // Solidity: function tssAddress() view returns(address) -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) TssAddress() (common.Address, error) { - return _GatewayUpgradeTest.Contract.TssAddress(&_GatewayUpgradeTest.CallOpts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) TssAddress() (common.Address, error) { - return _GatewayUpgradeTest.Contract.TssAddress(&_GatewayUpgradeTest.CallOpts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "execute", destination, data) +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Execute(&_GatewayUpgradeTest.TransactOpts, destination, data) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Execute(&_GatewayUpgradeTest.TransactOpts, destination, data) +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 (_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) +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 (_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) +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 (_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) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "initialize", _tssAddress) +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts, _tssAddress) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts, _tssAddress) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "renounceOwnership") +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) RenounceOwnership() (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.RenounceOwnership(&_GatewayUpgradeTest.TransactOpts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.RenounceOwnership(&_GatewayUpgradeTest.TransactOpts) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "send", recipient, amount) +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Send(&_GatewayUpgradeTest.TransactOpts, recipient, amount) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Send(&_GatewayUpgradeTest.TransactOpts, recipient, amount) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "sendERC20", recipient, token, amount) +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.SendERC20(&_GatewayUpgradeTest.TransactOpts, recipient, token, amount) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.SendERC20(&_GatewayUpgradeTest.TransactOpts, recipient, token, amount) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "setCustody", _custody) +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.SetCustody(&_GatewayUpgradeTest.TransactOpts, _custody) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.SetCustody(&_GatewayUpgradeTest.TransactOpts, _custody) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "transferOwnership", newOwner) +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.TransferOwnership(&_GatewayUpgradeTest.TransactOpts, newOwner) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.TransferOwnership(&_GatewayUpgradeTest.TransactOpts, newOwner) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "upgradeTo", newImplementation) +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.UpgradeTo(&_GatewayUpgradeTest.TransactOpts, newImplementation) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.UpgradeTo(&_GatewayUpgradeTest.TransactOpts, newImplementation) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +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 (_GatewayUpgradeTest *GatewayUpgradeTestSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.UpgradeToAndCall(&_GatewayUpgradeTest.TransactOpts, newImplementation, data) +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 (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.UpgradeToAndCall(&_GatewayUpgradeTest.TransactOpts, newImplementation, data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.UpgradeToAndCall(&_GatewayEVMUpgradeTest.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 +// 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 @@ -552,7 +552,7 @@ type GatewayUpgradeTestAdminChangedIterator 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 *GatewayUpgradeTestAdminChangedIterator) Next() bool { +func (it *GatewayEVMUpgradeTestAdminChangedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -561,7 +561,7 @@ func (it *GatewayUpgradeTestAdminChangedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestAdminChanged) + it.Event = new(GatewayEVMUpgradeTestAdminChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -576,7 +576,7 @@ func (it *GatewayUpgradeTestAdminChangedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestAdminChanged) + it.Event = new(GatewayEVMUpgradeTestAdminChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -592,19 +592,19 @@ func (it *GatewayUpgradeTestAdminChangedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestAdminChangedIterator) Error() error { +func (it *GatewayEVMUpgradeTestAdminChangedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestAdminChangedIterator) Close() error { +func (it *GatewayEVMUpgradeTestAdminChangedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestAdminChanged represents a AdminChanged event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestAdminChanged struct { +// 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 @@ -613,21 +613,21 @@ type GatewayUpgradeTestAdminChanged struct { // 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) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestAdminChangedIterator, error) { - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "AdminChanged") + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "AdminChanged") if err != nil { return nil, err } - return &GatewayUpgradeTestAdminChangedIterator{contract: _GatewayUpgradeTest.contract, event: "AdminChanged", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestAdminChanged) (event.Subscription, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestAdminChanged) (event.Subscription, error) { - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "AdminChanged") + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "AdminChanged") if err != nil { return nil, err } @@ -637,8 +637,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchAdminChanged(opts *b 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 { + event := new(GatewayEVMUpgradeTestAdminChanged) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "AdminChanged", log); err != nil { return err } event.Raw = log @@ -662,18 +662,18 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchAdminChanged(opts *b // 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 { +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 } -// 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 +// 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 @@ -687,7 +687,7 @@ type GatewayUpgradeTestBeaconUpgradedIterator 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 *GatewayUpgradeTestBeaconUpgradedIterator) Next() bool { +func (it *GatewayEVMUpgradeTestBeaconUpgradedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -696,7 +696,7 @@ func (it *GatewayUpgradeTestBeaconUpgradedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestBeaconUpgraded) + it.Event = new(GatewayEVMUpgradeTestBeaconUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -711,7 +711,7 @@ func (it *GatewayUpgradeTestBeaconUpgradedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestBeaconUpgraded) + it.Event = new(GatewayEVMUpgradeTestBeaconUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -727,19 +727,19 @@ func (it *GatewayUpgradeTestBeaconUpgradedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestBeaconUpgradedIterator) Error() error { +func (it *GatewayEVMUpgradeTestBeaconUpgradedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestBeaconUpgradedIterator) Close() error { +func (it *GatewayEVMUpgradeTestBeaconUpgradedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestBeaconUpgraded struct { +// GatewayEVMUpgradeTestBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestBeaconUpgraded struct { Beacon common.Address Raw types.Log // Blockchain specific contextual infos } @@ -747,31 +747,31 @@ type GatewayUpgradeTestBeaconUpgraded struct { // 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) { +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 := _GatewayUpgradeTest.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) if err != nil { return nil, err } - return &GatewayUpgradeTestBeaconUpgradedIterator{contract: _GatewayUpgradeTest.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { +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 := _GatewayUpgradeTest.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) if err != nil { return nil, err } @@ -781,8 +781,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchBeaconUpgraded(opts 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 { + event := new(GatewayEVMUpgradeTestBeaconUpgraded) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { return err } event.Raw = log @@ -806,18 +806,18 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchBeaconUpgraded(opts // 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 { +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 } -// 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 +// 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 @@ -831,7 +831,7 @@ type GatewayUpgradeTestExecutedV2Iterator 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 *GatewayUpgradeTestExecutedV2Iterator) Next() bool { +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -840,7 +840,7 @@ func (it *GatewayUpgradeTestExecutedV2Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedV2) + it.Event = new(GatewayEVMUpgradeTestExecutedV2) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -855,7 +855,7 @@ func (it *GatewayUpgradeTestExecutedV2Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedV2) + it.Event = new(GatewayEVMUpgradeTestExecutedV2) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -871,19 +871,19 @@ func (it *GatewayUpgradeTestExecutedV2Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestExecutedV2Iterator) Error() error { +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestExecutedV2Iterator) Close() error { +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestExecutedV2 represents a ExecutedV2 event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestExecutedV2 struct { +// GatewayEVMUpgradeTestExecutedV2 represents a ExecutedV2 event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedV2 struct { Destination common.Address Value *big.Int Data []byte @@ -893,31 +893,31 @@ type GatewayUpgradeTestExecutedV2 struct { // 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) { +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 := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedV2", destinationRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "ExecutedV2", destinationRule) if err != nil { return nil, err } - return &GatewayUpgradeTestExecutedV2Iterator{contract: _GatewayUpgradeTest.contract, event: "ExecutedV2", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedV2(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestExecutedV2, destination []common.Address) (event.Subscription, error) { +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 := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedV2", destinationRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "ExecutedV2", destinationRule) if err != nil { return nil, err } @@ -927,8 +927,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedV2(opts *bin 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 { + event := new(GatewayEVMUpgradeTestExecutedV2) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedV2", log); err != nil { return err } event.Raw = log @@ -952,18 +952,18 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedV2(opts *bin // 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 { +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 } -// GatewayUpgradeTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestExecutedWithERC20Iterator struct { - Event *GatewayUpgradeTestExecutedWithERC20 // Event containing the contract specifics and raw log +// 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 @@ -977,7 +977,7 @@ type GatewayUpgradeTestExecutedWithERC20Iterator 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 *GatewayUpgradeTestExecutedWithERC20Iterator) Next() bool { +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -986,7 +986,7 @@ func (it *GatewayUpgradeTestExecutedWithERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedWithERC20) + it.Event = new(GatewayEVMUpgradeTestExecutedWithERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1001,7 +1001,7 @@ func (it *GatewayUpgradeTestExecutedWithERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedWithERC20) + it.Event = new(GatewayEVMUpgradeTestExecutedWithERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1017,19 +1017,19 @@ func (it *GatewayUpgradeTestExecutedWithERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestExecutedWithERC20Iterator) Error() error { +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestExecutedWithERC20Iterator) Close() error { +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestExecutedWithERC20 struct { +// GatewayEVMUpgradeTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedWithERC20 struct { Token common.Address To common.Address Amount *big.Int @@ -1040,7 +1040,7 @@ type GatewayUpgradeTestExecutedWithERC20 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayUpgradeTestExecutedWithERC20Iterator, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMUpgradeTestExecutedWithERC20Iterator, error) { var tokenRule []interface{} for _, tokenItem := range token { @@ -1051,17 +1051,17 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedWithERC20(o toRule = append(toRule, toItem) } - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } - return &GatewayUpgradeTestExecutedWithERC20Iterator{contract: _GatewayUpgradeTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { +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 { @@ -1072,7 +1072,7 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20(op toRule = append(toRule, toItem) } - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } @@ -1082,8 +1082,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20(op select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestExecutedWithERC20) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + event := new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return err } event.Raw = log @@ -1107,18 +1107,18 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20(op // 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayUpgradeTestExecutedWithERC20, error) { - event := new(GatewayUpgradeTestExecutedWithERC20) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { +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 } -// 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 +// 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 @@ -1132,7 +1132,7 @@ type GatewayUpgradeTestInitializedIterator 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 *GatewayUpgradeTestInitializedIterator) Next() bool { +func (it *GatewayEVMUpgradeTestInitializedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1141,7 +1141,7 @@ func (it *GatewayUpgradeTestInitializedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestInitialized) + it.Event = new(GatewayEVMUpgradeTestInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1156,7 +1156,7 @@ func (it *GatewayUpgradeTestInitializedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestInitialized) + it.Event = new(GatewayEVMUpgradeTestInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1172,19 +1172,19 @@ func (it *GatewayUpgradeTestInitializedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestInitializedIterator) Error() error { +func (it *GatewayEVMUpgradeTestInitializedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestInitializedIterator) Close() error { +func (it *GatewayEVMUpgradeTestInitializedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestInitialized represents a Initialized event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestInitialized struct { +// GatewayEVMUpgradeTestInitialized represents a Initialized event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestInitialized struct { Version uint8 Raw types.Log // Blockchain specific contextual infos } @@ -1192,21 +1192,21 @@ type GatewayUpgradeTestInitialized struct { // 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) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestInitializedIterator, error) { - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Initialized") + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Initialized") if err != nil { return nil, err } - return &GatewayUpgradeTestInitializedIterator{contract: _GatewayUpgradeTest.contract, event: "Initialized", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestInitialized) (event.Subscription, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestInitialized) (event.Subscription, error) { - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "Initialized") + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Initialized") if err != nil { return nil, err } @@ -1216,8 +1216,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchInitialized(opts *bi 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 { + event := new(GatewayEVMUpgradeTestInitialized) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { return err } event.Raw = log @@ -1241,18 +1241,18 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchInitialized(opts *bi // 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 { +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 } -// 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 +// 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 @@ -1266,7 +1266,7 @@ type GatewayUpgradeTestOwnershipTransferredIterator 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 *GatewayUpgradeTestOwnershipTransferredIterator) Next() bool { +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1275,7 +1275,7 @@ func (it *GatewayUpgradeTestOwnershipTransferredIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestOwnershipTransferred) + it.Event = new(GatewayEVMUpgradeTestOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1290,7 +1290,7 @@ func (it *GatewayUpgradeTestOwnershipTransferredIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestOwnershipTransferred) + it.Event = new(GatewayEVMUpgradeTestOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1306,19 +1306,19 @@ func (it *GatewayUpgradeTestOwnershipTransferredIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestOwnershipTransferredIterator) Error() error { +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestOwnershipTransferredIterator) Close() error { +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestOwnershipTransferred struct { +// 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 @@ -1327,7 +1327,7 @@ type GatewayUpgradeTestOwnershipTransferred struct { // 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) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayEVMUpgradeTestOwnershipTransferredIterator, error) { var previousOwnerRule []interface{} for _, previousOwnerItem := range previousOwner { @@ -1338,17 +1338,17 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterOwnershipTransferre newOwnerRule = append(newOwnerRule, newOwnerItem) } - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } - return &GatewayUpgradeTestOwnershipTransferredIterator{contract: _GatewayUpgradeTest.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { +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 { @@ -1359,7 +1359,7 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchOwnershipTransferred newOwnerRule = append(newOwnerRule, newOwnerItem) } - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } @@ -1369,8 +1369,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchOwnershipTransferred 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 { + event := new(GatewayEVMUpgradeTestOwnershipTransferred) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return err } event.Raw = log @@ -1394,18 +1394,18 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchOwnershipTransferred // 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 { +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 } -// GatewayUpgradeTestSendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestSendIterator struct { - Event *GatewayUpgradeTestSend // Event containing the contract specifics and raw log +// 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 @@ -1419,7 +1419,7 @@ type GatewayUpgradeTestSendIterator 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 *GatewayUpgradeTestSendIterator) Next() bool { +func (it *GatewayEVMUpgradeTestSendIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1428,7 +1428,7 @@ func (it *GatewayUpgradeTestSendIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestSend) + it.Event = new(GatewayEVMUpgradeTestSend) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1443,7 +1443,7 @@ func (it *GatewayUpgradeTestSendIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestSend) + it.Event = new(GatewayEVMUpgradeTestSend) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1459,19 +1459,19 @@ func (it *GatewayUpgradeTestSendIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestSendIterator) Error() error { +func (it *GatewayEVMUpgradeTestSendIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestSendIterator) Close() error { +func (it *GatewayEVMUpgradeTestSendIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestSend represents a Send event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestSend struct { +// 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 @@ -1480,21 +1480,21 @@ type GatewayUpgradeTestSend struct { // FilterSend is a free log retrieval operation binding the contract event 0xa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58. // // Solidity: event Send(bytes recipient, uint256 amount) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterSend(opts *bind.FilterOpts) (*GatewayUpgradeTestSendIterator, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterSend(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestSendIterator, error) { - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Send") + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Send") if err != nil { return nil, err } - return &GatewayUpgradeTestSendIterator{contract: _GatewayUpgradeTest.contract, event: "Send", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestSend) (event.Subscription, error) { +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestSend) (event.Subscription, error) { - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "Send") + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Send") if err != nil { return nil, err } @@ -1504,8 +1504,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchSend(opts *bind.Watc select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestSend) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Send", log); err != nil { + event := new(GatewayEVMUpgradeTestSend) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Send", log); err != nil { return err } event.Raw = log @@ -1529,18 +1529,18 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchSend(opts *bind.Watc // ParseSend is a log parse operation binding the contract event 0xa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58. // // Solidity: event Send(bytes recipient, uint256 amount) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseSend(log types.Log) (*GatewayUpgradeTestSend, error) { - event := new(GatewayUpgradeTestSend) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Send", log); err != nil { +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 } -// GatewayUpgradeTestSendERC20Iterator is returned from FilterSendERC20 and is used to iterate over the raw logs and unpacked data for SendERC20 events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestSendERC20Iterator struct { - Event *GatewayUpgradeTestSendERC20 // Event containing the contract specifics and raw log +// 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 @@ -1554,7 +1554,7 @@ type GatewayUpgradeTestSendERC20Iterator 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 *GatewayUpgradeTestSendERC20Iterator) Next() bool { +func (it *GatewayEVMUpgradeTestSendERC20Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1563,7 +1563,7 @@ func (it *GatewayUpgradeTestSendERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestSendERC20) + it.Event = new(GatewayEVMUpgradeTestSendERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1578,7 +1578,7 @@ func (it *GatewayUpgradeTestSendERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestSendERC20) + it.Event = new(GatewayEVMUpgradeTestSendERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1594,19 +1594,19 @@ func (it *GatewayUpgradeTestSendERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestSendERC20Iterator) Error() error { +func (it *GatewayEVMUpgradeTestSendERC20Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestSendERC20Iterator) Close() error { +func (it *GatewayEVMUpgradeTestSendERC20Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestSendERC20 represents a SendERC20 event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestSendERC20 struct { +// GatewayEVMUpgradeTestSendERC20 represents a SendERC20 event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestSendERC20 struct { Recipient []byte Asset common.Address Amount *big.Int @@ -1616,31 +1616,31 @@ type GatewayUpgradeTestSendERC20 struct { // FilterSendERC20 is a free log retrieval operation binding the contract event 0x35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af. // // Solidity: event SendERC20(bytes recipient, address indexed asset, uint256 amount) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterSendERC20(opts *bind.FilterOpts, asset []common.Address) (*GatewayUpgradeTestSendERC20Iterator, error) { +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 := _GatewayUpgradeTest.contract.FilterLogs(opts, "SendERC20", assetRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "SendERC20", assetRule) if err != nil { return nil, err } - return &GatewayUpgradeTestSendERC20Iterator{contract: _GatewayUpgradeTest.contract, event: "SendERC20", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchSendERC20(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestSendERC20, asset []common.Address) (event.Subscription, error) { +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 := _GatewayUpgradeTest.contract.WatchLogs(opts, "SendERC20", assetRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "SendERC20", assetRule) if err != nil { return nil, err } @@ -1650,8 +1650,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchSendERC20(opts *bind select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestSendERC20) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "SendERC20", log); err != nil { + event := new(GatewayEVMUpgradeTestSendERC20) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "SendERC20", log); err != nil { return err } event.Raw = log @@ -1675,18 +1675,18 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchSendERC20(opts *bind // ParseSendERC20 is a log parse operation binding the contract event 0x35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af. // // Solidity: event SendERC20(bytes recipient, address indexed asset, uint256 amount) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseSendERC20(log types.Log) (*GatewayUpgradeTestSendERC20, error) { - event := new(GatewayUpgradeTestSendERC20) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "SendERC20", log); err != nil { +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 } -// 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 +// 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 @@ -1700,7 +1700,7 @@ type GatewayUpgradeTestUpgradedIterator 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 *GatewayUpgradeTestUpgradedIterator) Next() bool { +func (it *GatewayEVMUpgradeTestUpgradedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1709,7 +1709,7 @@ func (it *GatewayUpgradeTestUpgradedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestUpgraded) + it.Event = new(GatewayEVMUpgradeTestUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1724,7 +1724,7 @@ func (it *GatewayUpgradeTestUpgradedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayUpgradeTestUpgraded) + it.Event = new(GatewayEVMUpgradeTestUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1740,19 +1740,19 @@ func (it *GatewayUpgradeTestUpgradedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestUpgradedIterator) Error() error { +func (it *GatewayEVMUpgradeTestUpgradedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayUpgradeTestUpgradedIterator) Close() error { +func (it *GatewayEVMUpgradeTestUpgradedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayUpgradeTestUpgraded represents a Upgraded event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestUpgraded struct { +// GatewayEVMUpgradeTestUpgraded represents a Upgraded event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestUpgraded struct { Implementation common.Address Raw types.Log // Blockchain specific contextual infos } @@ -1760,31 +1760,31 @@ type GatewayUpgradeTestUpgraded struct { // 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) { +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 := _GatewayUpgradeTest.contract.FilterLogs(opts, "Upgraded", implementationRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Upgraded", implementationRule) if err != nil { return nil, err } - return &GatewayUpgradeTestUpgradedIterator{contract: _GatewayUpgradeTest.contract, event: "Upgraded", logs: logs, sub: sub}, nil + 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 (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestUpgraded, implementation []common.Address) (event.Subscription, error) { +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 := _GatewayUpgradeTest.contract.WatchLogs(opts, "Upgraded", implementationRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Upgraded", implementationRule) if err != nil { return nil, err } @@ -1794,8 +1794,8 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchUpgraded(opts *bind. 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 { + event := new(GatewayEVMUpgradeTestUpgraded) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Upgraded", log); err != nil { return err } event.Raw = log @@ -1819,9 +1819,9 @@ func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchUpgraded(opts *bind. // 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 { +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 diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/igateway.go b/pkg/contracts/prototypes/evm/interfaces.sol/igateway.go deleted file mode 100644 index 908b2546..00000000 --- a/pkg/contracts/prototypes/evm/interfaces.sol/igateway.go +++ /dev/null @@ -1,265 +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\"},{\"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\"}]", -} - -// 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) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_IGateway *IGatewayTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _IGateway.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 (_IGateway *IGatewaySession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _IGateway.Contract.Send(&_IGateway.TransactOpts, recipient, amount) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_IGateway *IGatewayTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _IGateway.Contract.Send(&_IGateway.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 (_IGateway *IGatewayTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { - return _IGateway.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 (_IGateway *IGatewaySession) SendERC20(recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { - return _IGateway.Contract.SendERC20(&_IGateway.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 (_IGateway *IGatewayTransactorSession) SendERC20(recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { - return _IGateway.Contract.SendERC20(&_IGateway.TransactOpts, recipient, asset, amount) -} 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/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 6141aa9c..d98bf489 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -2,7 +2,7 @@ import { expect } from "chai"; import { BigNumber, Contract } from "ethers"; import { ethers, upgrades } from "hardhat"; -describe("Gateway and Receiver", function () { +describe("GatewayEVM and Receiver", function () { let receiver: Contract; let gateway: Contract; let token: Contract; @@ -12,7 +12,7 @@ describe("Gateway and Receiver", function () { 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, tssAddress] = await ethers.getSigners(); @@ -125,7 +125,7 @@ describe("Gateway and Receiver", function () { }); }); -describe("Gateway evm inbound", function () { +describe("GatewayEVM inbound", function () { let gateway: Contract; let token: Contract; let custody: Contract; @@ -133,7 +133,7 @@ describe("Gateway evm inbound", function () { beforeEach(async function () { const TestERC20 = await ethers.getContractFactory("TestERC20"); - const Gateway = await ethers.getContractFactory("Gateway"); + const Gateway = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); [owner, destination, tssAddress] = await ethers.getSigners(); @@ -168,7 +168,9 @@ describe("Gateway evm inbound", function () { const ownerBalanceAfter = await token.balanceOf(owner.address); expect(ownerBalanceAfter).to.equal(ethers.utils.parseEther("900")); - await expect(tx).to.emit(gateway, "SendERC20").withArgs(destination.address.toLowerCase(), token.address, amount); + await expect(tx) + .to.emit(gateway, "SendERC20") + .withArgs(owner.address, destination.address.toLowerCase(), token.address, amount); }); it("should send eth to tss address and emit event", async function () { @@ -182,7 +184,7 @@ describe("Gateway evm inbound", function () { const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); - await expect(tx).to.emit(gateway, "Send").withArgs(destination.address.toLowerCase(), amount); + await expect(tx).to.emit(gateway, "Send").withArgs(owner.address, destination.address.toLowerCase(), amount); }); it("should fail to send to tss address if msg.value lower than amount", async function () { diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayUniswap.spec.ts index a7b58487..c4e392fa 100644 --- a/test/prototypes/GatewayUniswap.spec.ts +++ b/test/prototypes/GatewayUniswap.spec.ts @@ -6,7 +6,7 @@ import { UniswapV2Deployer } from "uniswap-v2-deploy-plugin"; import { ERC20, ERC20CustodyNew, - Gateway, + GatewayEVM, Receiver, TestERC20, UniswapV2Factory, @@ -14,14 +14,14 @@ 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; @@ -57,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, [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/GatewayUpgrade.spec.ts index ad9afcd8..a11c1fc6 100644 --- a/test/prototypes/GatewayUpgrade.spec.ts +++ b/test/prototypes/GatewayUpgrade.spec.ts @@ -2,7 +2,7 @@ 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; @@ -12,7 +12,7 @@ describe("Gateway upgrade", function () { 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, tssAddress] = await ethers.getSigners(); @@ -37,13 +37,13 @@ describe("Gateway upgrade", function () { 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); + 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 diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts new file mode 100644 index 00000000..652f4914 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts @@ -0,0 +1,715 @@ +/* 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: { + "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(address,bytes,uint256)": EventFragment; + "SendERC20(address,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 { + sender: string; + recipient: string; + amount: BigNumber; +} +export type SendEvent = TypedEvent< + [string, string, BigNumber], + SendEventObject +>; + +export type SendEventFilter = TypedEventFilter; + +export interface SendERC20EventObject { + sender: string; + recipient: string; + asset: string; + amount: BigNumber; +} +export type SendERC20Event = TypedEvent< + [string, 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 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: { + 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(address,bytes,uint256)"( + sender?: null, + recipient?: null, + amount?: null + ): SendEventFilter; + Send(sender?: null, recipient?: null, amount?: null): SendEventFilter; + + "SendERC20(address,bytes,address,uint256)"( + sender?: null, + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + SendERC20( + sender?: null, + 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/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/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 8e3200c1..356b9286 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -4,7 +4,7 @@ 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 { 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/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 index 878cfe66..a354144f 100644 --- a/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts @@ -1,4 +1,4 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export type { IGateway } from "./IGateway"; +export type { IGatewayEVM } from "./IGatewayEVM"; diff --git a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts index 3446cb5f..74e05a97 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts @@ -82,7 +82,7 @@ const _abi = [ name: "gateway", outputs: [ { - internalType: "contract IGateway", + internalType: "contract IGatewayEVM", 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/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts new file mode 100644 index 00000000..db594578 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -0,0 +1,492 @@ +/* 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", + }, + { + 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 = + "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c6126b5620002436000396000818161038701528181610416015281816105100152818161059f015261093b01526126b56000f3fe6080604052600436106100dd5760003560e01c80638da5cb5b1161007f578063c4d66de811610059578063c4d66de814610271578063cb0271ed1461029a578063dda79b75146102c3578063f2fde38b146102ee576100dd565b80638da5cb5b146102015780639372c4ab1461022c578063ae7a3a6f14610248576100dd565b80635131ab59116100bb5780635131ab591461015757806352d1902d146101945780635b112591146101bf578063715018a6146101ea576100dd565b80631cff79cd146100e25780633659cfe6146101125780634f1ef2861461013b575b600080fd5b6100fc60048036038101906100f791906118d1565b610317565b6040516101099190611f02565b60405180910390f35b34801561011e57600080fd5b506101396004803603810190610134919061181c565b610385565b005b61015560048036038101906101509190611931565b61050e565b005b34801561016357600080fd5b5061017e60048036038101906101799190611849565b61064b565b60405161018b9190611f02565b60405180910390f35b3480156101a057600080fd5b506101a9610937565b6040516101b69190611eb5565b60405180910390f35b3480156101cb57600080fd5b506101d46109f0565b6040516101e19190611e11565b60405180910390f35b3480156101f657600080fd5b506101ff610a16565b005b34801561020d57600080fd5b50610216610a2a565b6040516102239190611e11565b60405180910390f35b61024660048036038101906102419190611a5b565b610a54565b005b34801561025457600080fd5b5061026f600480360381019061026a919061181c565b610b9c565b005b34801561027d57600080fd5b506102986004803603810190610293919061181c565b610be0565b005b3480156102a657600080fd5b506102c160048036038101906102bc91906119e7565b610d68565b005b3480156102cf57600080fd5b506102d8610e72565b6040516102e59190611e11565b60405180910390f35b3480156102fa57600080fd5b506103156004803603810190610310919061181c565b610e98565b005b60606000610326858585610f1c565b90508473ffffffffffffffffffffffffffffffffffffffff167f373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546348686604051610372939291906120c1565b60405180910390a2809150509392505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610414576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161040b90611f81565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610453610fd3565b73ffffffffffffffffffffffffffffffffffffffff16146104a9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104a090611fa1565b60405180910390fd5b6104b28161102a565b61050b81600067ffffffffffffffff8111156104d1576104d0612282565b5b6040519080825280601f01601f1916602001820160405280156105035781602001600182028036833780820191505090505b506000611035565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16141561059d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161059490611f81565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166105dc610fd3565b73ffffffffffffffffffffffffffffffffffffffff1614610632576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161062990611fa1565b60405180910390fd5b61063b8261102a565b61064782826001611035565b5050565b60608573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b8152600401610688929190611e8c565b602060405180830381600087803b1580156106a257600080fd5b505af11580156106b6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106da919061198d565b5060006106e8868585610f1c565b90508673ffffffffffffffffffffffffffffffffffffffff1663095ea7b38760006040518363ffffffff1660e01b8152600401610726929190611e63565b602060405180830381600087803b15801561074057600080fd5b505af1158015610754573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610778919061198d565b5060008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016107b49190611e11565b60206040518083038186803b1580156107cc57600080fd5b505afa1580156107e0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108049190611abb565b905060008111156108c0578773ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff1660e01b815260040161086c929190611e8c565b602060405180830381600087803b15801561088657600080fd5b505af115801561089a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108be919061198d565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610921939291906120c1565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16146109c7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109be90611fc1565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610a1e6111b2565b610a286000611230565b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b80341015610a8e576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1682604051610ad690611dfc565b60006040518083038185875af1925050503d8060008114610b13576040519150601f19603f3d011682016040523d82523d6000602084013e610b18565b606091505b50509050600015158115151415610b5b576040517f81063e5100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7fa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58848484604051610b8e93929190611ed0565b60405180910390a150505050565b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610c115750600160008054906101000a900460ff1660ff16105b80610c3e5750610c20306112f6565b158015610c3d5750600160008054906101000a900460ff1660ff16145b5b610c7d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c7490612001565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610cba576001600060016101000a81548160ff0219169083151502179055505b610cc2611319565b610cca611372565b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508015610d645760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610d5b9190611f24565b60405180910390a15b5050565b8173ffffffffffffffffffffffffffffffffffffffff166323b872dd3360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b8152600401610dc793929190611e2c565b602060405180830381600087803b158015610de157600080fd5b505af1158015610df5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e19919061198d565b508173ffffffffffffffffffffffffffffffffffffffff167f35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af858584604051610e6493929190611ed0565b60405180910390a250505050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610ea06111b2565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610f10576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f0790611f61565b60405180910390fd5b610f1981611230565b50565b60606000808573ffffffffffffffffffffffffffffffffffffffff16348686604051610f49929190611dcc565b60006040518083038185875af1925050503d8060008114610f86576040519150601f19603f3d011682016040523d82523d6000602084013e610f8b565b606091505b509150915081610fc7576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006110017f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c3565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6110326111b2565b50565b6110617f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6113cd565b60000160009054906101000a900460ff161561108557611080836113d7565b6111ad565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110cb57600080fd5b505afa9250505080156110fc57506040513d601f19601f820116820180604052508101906110f991906119ba565b60015b61113b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161113290612021565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b81146111a0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161119790611fe1565b60405180910390fd5b506111ac838383611490565b5b505050565b6111ba6114bc565b73ffffffffffffffffffffffffffffffffffffffff166111d8610a2a565b73ffffffffffffffffffffffffffffffffffffffff161461122e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161122590612061565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611368576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161135f906120a1565b60405180910390fd5b6113706114c4565b565b600060019054906101000a900460ff166113c1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113b8906120a1565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6113e0816112f6565b61141f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161141690612041565b60405180910390fd5b8061144c7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c3565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b61149983611525565b6000825111806114a65750805b156114b7576114b58383611574565b505b505050565b600033905090565b600060019054906101000a900460ff16611513576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150a906120a1565b60405180910390fd5b61152361151e6114bc565b611230565b565b61152e816113d7565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b60606115998383604051806060016040528060278152602001612659602791396115a1565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516115cb9190611de5565b600060405180830381855af49150503d8060008114611606576040519150601f19603f3d011682016040523d82523d6000602084013e61160b565b606091505b509150915061161c86838387611627565b925050509392505050565b6060831561168a5760008351141561168257611642856112f6565b611681576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161167890612081565b60405180910390fd5b5b829050611695565b611694838361169d565b5b949350505050565b6000825111156116b05781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116e49190611f3f565b60405180910390fd5b60006117006116fb84612118565b6120f3565b90508281526020810184848401111561171c5761171b6122c0565b5b61172784828561220f565b509392505050565b60008135905061173e816125fc565b92915050565b60008151905061175381612613565b92915050565b6000815190506117688161262a565b92915050565b60008083601f840112611784576117836122b6565b5b8235905067ffffffffffffffff8111156117a1576117a06122b1565b5b6020830191508360018202830111156117bd576117bc6122bb565b5b9250929050565b600082601f8301126117d9576117d86122b6565b5b81356117e98482602086016116ed565b91505092915050565b60008135905061180181612641565b92915050565b60008151905061181681612641565b92915050565b600060208284031215611832576118316122ca565b5b60006118408482850161172f565b91505092915050565b600080600080600060808688031215611865576118646122ca565b5b60006118738882890161172f565b95505060206118848882890161172f565b9450506040611895888289016117f2565b935050606086013567ffffffffffffffff8111156118b6576118b56122c5565b5b6118c28882890161176e565b92509250509295509295909350565b6000806000604084860312156118ea576118e96122ca565b5b60006118f88682870161172f565b935050602084013567ffffffffffffffff811115611919576119186122c5565b5b6119258682870161176e565b92509250509250925092565b60008060408385031215611948576119476122ca565b5b60006119568582860161172f565b925050602083013567ffffffffffffffff811115611977576119766122c5565b5b611983858286016117c4565b9150509250929050565b6000602082840312156119a3576119a26122ca565b5b60006119b184828501611744565b91505092915050565b6000602082840312156119d0576119cf6122ca565b5b60006119de84828501611759565b91505092915050565b60008060008060608587031215611a0157611a006122ca565b5b600085013567ffffffffffffffff811115611a1f57611a1e6122c5565b5b611a2b8782880161176e565b94509450506020611a3e8782880161172f565b9250506040611a4f878288016117f2565b91505092959194509250565b600080600060408486031215611a7457611a736122ca565b5b600084013567ffffffffffffffff811115611a9257611a916122c5565b5b611a9e8682870161176e565b93509350506020611ab1868287016117f2565b9150509250925092565b600060208284031215611ad157611ad06122ca565b5b6000611adf84828501611807565b91505092915050565b611af18161218c565b82525050565b611b00816121aa565b82525050565b6000611b12838561215f565b9350611b1f83858461220f565b611b28836122cf565b840190509392505050565b6000611b3f8385612170565b9350611b4c83858461220f565b82840190509392505050565b6000611b6382612149565b611b6d818561215f565b9350611b7d81856020860161221e565b611b86816122cf565b840191505092915050565b6000611b9c82612149565b611ba68185612170565b9350611bb681856020860161221e565b80840191505092915050565b611bcb816121eb565b82525050565b611bda816121fd565b82525050565b6000611beb82612154565b611bf5818561217b565b9350611c0581856020860161221e565b611c0e816122cf565b840191505092915050565b6000611c2660268361217b565b9150611c31826122e0565b604082019050919050565b6000611c49602c8361217b565b9150611c548261232f565b604082019050919050565b6000611c6c602c8361217b565b9150611c778261237e565b604082019050919050565b6000611c8f60388361217b565b9150611c9a826123cd565b604082019050919050565b6000611cb260298361217b565b9150611cbd8261241c565b604082019050919050565b6000611cd5602e8361217b565b9150611ce08261246b565b604082019050919050565b6000611cf8602e8361217b565b9150611d03826124ba565b604082019050919050565b6000611d1b602d8361217b565b9150611d2682612509565b604082019050919050565b6000611d3e60208361217b565b9150611d4982612558565b602082019050919050565b6000611d61600083612170565b9150611d6c82612581565b600082019050919050565b6000611d84601d8361217b565b9150611d8f82612584565b602082019050919050565b6000611da7602b8361217b565b9150611db2826125ad565b604082019050919050565b611dc6816121d4565b82525050565b6000611dd9828486611b33565b91508190509392505050565b6000611df18284611b91565b915081905092915050565b6000611e0782611d54565b9150819050919050565b6000602082019050611e266000830184611ae8565b92915050565b6000606082019050611e416000830186611ae8565b611e4e6020830185611ae8565b611e5b6040830184611dbd565b949350505050565b6000604082019050611e786000830185611ae8565b611e856020830184611bc2565b9392505050565b6000604082019050611ea16000830185611ae8565b611eae6020830184611dbd565b9392505050565b6000602082019050611eca6000830184611af7565b92915050565b60006040820190508181036000830152611eeb818587611b06565b9050611efa6020830184611dbd565b949350505050565b60006020820190508181036000830152611f1c8184611b58565b905092915050565b6000602082019050611f396000830184611bd1565b92915050565b60006020820190508181036000830152611f598184611be0565b905092915050565b60006020820190508181036000830152611f7a81611c19565b9050919050565b60006020820190508181036000830152611f9a81611c3c565b9050919050565b60006020820190508181036000830152611fba81611c5f565b9050919050565b60006020820190508181036000830152611fda81611c82565b9050919050565b60006020820190508181036000830152611ffa81611ca5565b9050919050565b6000602082019050818103600083015261201a81611cc8565b9050919050565b6000602082019050818103600083015261203a81611ceb565b9050919050565b6000602082019050818103600083015261205a81611d0e565b9050919050565b6000602082019050818103600083015261207a81611d31565b9050919050565b6000602082019050818103600083015261209a81611d77565b9050919050565b600060208201905081810360008301526120ba81611d9a565b9050919050565b60006040820190506120d66000830186611dbd565b81810360208301526120e9818486611b06565b9050949350505050565b60006120fd61210e565b90506121098282612251565b919050565b6000604051905090565b600067ffffffffffffffff82111561213357612132612282565b5b61213c826122cf565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612197826121b4565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006121f6826121d4565b9050919050565b6000612208826121de565b9050919050565b82818337600083830152505050565b60005b8381101561223c578082015181840152602081019050612221565b8381111561224b576000848401525b50505050565b61225a826122cf565b810181811067ffffffffffffffff8211171561227957612278612282565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b6126058161218c565b811461261057600080fd5b50565b61261c8161219e565b811461262757600080fd5b50565b612633816121aa565b811461263e57600080fd5b50565b61264a816121d4565b811461265557600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a26469706673582212206239514dc9c1a747373cb80f91c7b09bba990ac44aa1e1d6c2aaeae3d4413a0064736f6c63430008070033"; + +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..ff008449 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -0,0 +1,500 @@ +/* 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: "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: "address", + name: "sender", + type: "address", + }, + { + 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: "address", + name: "sender", + type: "address", + }, + { + 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 = + "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c6126c7620002436000396000818161038701528181610416015281816105100152818161059f015261093b01526126c76000f3fe6080604052600436106100dd5760003560e01c80638da5cb5b1161007f578063c4d66de811610059578063c4d66de814610271578063cb0271ed1461029a578063dda79b75146102c3578063f2fde38b146102ee576100dd565b80638da5cb5b146102015780639372c4ab1461022c578063ae7a3a6f14610248576100dd565b80635131ab59116100bb5780635131ab591461015757806352d1902d146101945780635b112591146101bf578063715018a6146101ea576100dd565b80631cff79cd146100e25780633659cfe6146101125780634f1ef2861461013b575b600080fd5b6100fc60048036038101906100f791906118d5565b610317565b6040516101099190611f14565b60405180910390f35b34801561011e57600080fd5b5061013960048036038101906101349190611820565b610385565b005b61015560048036038101906101509190611935565b61050e565b005b34801561016357600080fd5b5061017e6004803603810190610179919061184d565b61064b565b60405161018b9190611f14565b60405180910390f35b3480156101a057600080fd5b506101a9610937565b6040516101b69190611ef9565b60405180910390f35b3480156101cb57600080fd5b506101d46109f0565b6040516101e19190611e15565b60405180910390f35b3480156101f657600080fd5b506101ff610a16565b005b34801561020d57600080fd5b50610216610a2a565b6040516102239190611e15565b60405180910390f35b61024660048036038101906102419190611a5f565b610a54565b005b34801561025457600080fd5b5061026f600480360381019061026a9190611820565b610b9e565b005b34801561027d57600080fd5b5061029860048036038101906102939190611820565b610be2565b005b3480156102a657600080fd5b506102c160048036038101906102bc91906119eb565b610d6a565b005b3480156102cf57600080fd5b506102d8610e76565b6040516102e59190611e15565b60405180910390f35b3480156102fa57600080fd5b5061031560048036038101906103109190611820565b610e9c565b005b60606000610326858585610f20565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f348686604051610372939291906120d3565b60405180910390a2809150509392505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610414576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161040b90611f93565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610453610fd7565b73ffffffffffffffffffffffffffffffffffffffff16146104a9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104a090611fb3565b60405180910390fd5b6104b28161102e565b61050b81600067ffffffffffffffff8111156104d1576104d0612294565b5b6040519080825280601f01601f1916602001820160405280156105035781602001600182028036833780820191505090505b506000611039565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16141561059d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161059490611f93565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166105dc610fd7565b73ffffffffffffffffffffffffffffffffffffffff1614610632576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161062990611fb3565b60405180910390fd5b61063b8261102e565b61064782826001611039565b5050565b60608573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b8152600401610688929190611ed0565b602060405180830381600087803b1580156106a257600080fd5b505af11580156106b6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106da9190611991565b5060006106e8868585610f20565b90508673ffffffffffffffffffffffffffffffffffffffff1663095ea7b38760006040518363ffffffff1660e01b8152600401610726929190611ea7565b602060405180830381600087803b15801561074057600080fd5b505af1158015610754573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107789190611991565b5060008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016107b49190611e15565b60206040518083038186803b1580156107cc57600080fd5b505afa1580156107e0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108049190611abf565b905060008111156108c0578773ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff1660e01b815260040161086c929190611ed0565b602060405180830381600087803b15801561088657600080fd5b505af115801561089a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108be9190611991565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610921939291906120d3565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16146109c7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109be90611fd3565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610a1e6111b6565b610a286000611234565b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b80341015610a8e576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1682604051610ad690611e00565b60006040518083038185875af1925050503d8060008114610b13576040519150601f19603f3d011682016040523d82523d6000602084013e610b18565b606091505b50509050600015158115151415610b5b576040517f81063e5100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f84583322b159855a8990ae36b9708ebcb1d1c7fdccf3cd41e19e4f65f00bb2b633858585604051610b909493929190611e67565b60405180910390a150505050565b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610c135750600160008054906101000a900460ff1660ff16105b80610c405750610c22306112fa565b158015610c3f5750600160008054906101000a900460ff1660ff16145b5b610c7f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c7690612013565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610cbc576001600060016101000a81548160ff0219169083151502179055505b610cc461131d565b610ccc611376565b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508015610d665760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610d5d9190611f36565b60405180910390a15b5050565b8173ffffffffffffffffffffffffffffffffffffffff166323b872dd3360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b8152600401610dc993929190611e30565b602060405180830381600087803b158015610de357600080fd5b505af1158015610df7573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e1b9190611991565b508173ffffffffffffffffffffffffffffffffffffffff167ff31c5882db91f6b727bb3fe49d02ca7e0e036d99bd5f6bb64cb0c8d9f74f991133868685604051610e689493929190611e67565b60405180910390a250505050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610ea46111b6565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610f14576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f0b90611f73565b60405180910390fd5b610f1d81611234565b50565b60606000808573ffffffffffffffffffffffffffffffffffffffff16348686604051610f4d929190611dd0565b60006040518083038185875af1925050503d8060008114610f8a576040519150601f19603f3d011682016040523d82523d6000602084013e610f8f565b606091505b509150915081610fcb576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006110057f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c7565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6110366111b6565b50565b6110657f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6113d1565b60000160009054906101000a900460ff161561108957611084836113db565b6111b1565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110cf57600080fd5b505afa92505050801561110057506040513d601f19601f820116820180604052508101906110fd91906119be565b60015b61113f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161113690612033565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b81146111a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161119b90611ff3565b60405180910390fd5b506111b0838383611494565b5b505050565b6111be6114c0565b73ffffffffffffffffffffffffffffffffffffffff166111dc610a2a565b73ffffffffffffffffffffffffffffffffffffffff1614611232576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161122990612073565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff1661136c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611363906120b3565b60405180910390fd5b6113746114c8565b565b600060019054906101000a900460ff166113c5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113bc906120b3565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6113e4816112fa565b611423576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161141a90612053565b60405180910390fd5b806114507f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c7565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b61149d83611529565b6000825111806114aa5750805b156114bb576114b98383611578565b505b505050565b600033905090565b600060019054906101000a900460ff16611517576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150e906120b3565b60405180910390fd5b6115276115226114c0565b611234565b565b611532816113db565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b606061159d838360405180606001604052806027815260200161266b602791396115a5565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516115cf9190611de9565b600060405180830381855af49150503d806000811461160a576040519150601f19603f3d011682016040523d82523d6000602084013e61160f565b606091505b50915091506116208683838761162b565b925050509392505050565b6060831561168e5760008351141561168657611646856112fa565b611685576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161167c90612093565b60405180910390fd5b5b829050611699565b61169883836116a1565b5b949350505050565b6000825111156116b45781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116e89190611f51565b60405180910390fd5b60006117046116ff8461212a565b612105565b9050828152602081018484840111156117205761171f6122d2565b5b61172b848285612221565b509392505050565b6000813590506117428161260e565b92915050565b60008151905061175781612625565b92915050565b60008151905061176c8161263c565b92915050565b60008083601f840112611788576117876122c8565b5b8235905067ffffffffffffffff8111156117a5576117a46122c3565b5b6020830191508360018202830111156117c1576117c06122cd565b5b9250929050565b600082601f8301126117dd576117dc6122c8565b5b81356117ed8482602086016116f1565b91505092915050565b60008135905061180581612653565b92915050565b60008151905061181a81612653565b92915050565b600060208284031215611836576118356122dc565b5b600061184484828501611733565b91505092915050565b600080600080600060808688031215611869576118686122dc565b5b600061187788828901611733565b955050602061188888828901611733565b9450506040611899888289016117f6565b935050606086013567ffffffffffffffff8111156118ba576118b96122d7565b5b6118c688828901611772565b92509250509295509295909350565b6000806000604084860312156118ee576118ed6122dc565b5b60006118fc86828701611733565b935050602084013567ffffffffffffffff81111561191d5761191c6122d7565b5b61192986828701611772565b92509250509250925092565b6000806040838503121561194c5761194b6122dc565b5b600061195a85828601611733565b925050602083013567ffffffffffffffff81111561197b5761197a6122d7565b5b611987858286016117c8565b9150509250929050565b6000602082840312156119a7576119a66122dc565b5b60006119b584828501611748565b91505092915050565b6000602082840312156119d4576119d36122dc565b5b60006119e28482850161175d565b91505092915050565b60008060008060608587031215611a0557611a046122dc565b5b600085013567ffffffffffffffff811115611a2357611a226122d7565b5b611a2f87828801611772565b94509450506020611a4287828801611733565b9250506040611a53878288016117f6565b91505092959194509250565b600080600060408486031215611a7857611a776122dc565b5b600084013567ffffffffffffffff811115611a9657611a956122d7565b5b611aa286828701611772565b93509350506020611ab5868287016117f6565b9150509250925092565b600060208284031215611ad557611ad46122dc565b5b6000611ae38482850161180b565b91505092915050565b611af58161219e565b82525050565b611b04816121bc565b82525050565b6000611b168385612171565b9350611b23838584612221565b611b2c836122e1565b840190509392505050565b6000611b438385612182565b9350611b50838584612221565b82840190509392505050565b6000611b678261215b565b611b718185612171565b9350611b81818560208601612230565b611b8a816122e1565b840191505092915050565b6000611ba08261215b565b611baa8185612182565b9350611bba818560208601612230565b80840191505092915050565b611bcf816121fd565b82525050565b611bde8161220f565b82525050565b6000611bef82612166565b611bf9818561218d565b9350611c09818560208601612230565b611c12816122e1565b840191505092915050565b6000611c2a60268361218d565b9150611c35826122f2565b604082019050919050565b6000611c4d602c8361218d565b9150611c5882612341565b604082019050919050565b6000611c70602c8361218d565b9150611c7b82612390565b604082019050919050565b6000611c9360388361218d565b9150611c9e826123df565b604082019050919050565b6000611cb660298361218d565b9150611cc18261242e565b604082019050919050565b6000611cd9602e8361218d565b9150611ce48261247d565b604082019050919050565b6000611cfc602e8361218d565b9150611d07826124cc565b604082019050919050565b6000611d1f602d8361218d565b9150611d2a8261251b565b604082019050919050565b6000611d4260208361218d565b9150611d4d8261256a565b602082019050919050565b6000611d65600083612182565b9150611d7082612593565b600082019050919050565b6000611d88601d8361218d565b9150611d9382612596565b602082019050919050565b6000611dab602b8361218d565b9150611db6826125bf565b604082019050919050565b611dca816121e6565b82525050565b6000611ddd828486611b37565b91508190509392505050565b6000611df58284611b95565b915081905092915050565b6000611e0b82611d58565b9150819050919050565b6000602082019050611e2a6000830184611aec565b92915050565b6000606082019050611e456000830186611aec565b611e526020830185611aec565b611e5f6040830184611dc1565b949350505050565b6000606082019050611e7c6000830187611aec565b8181036020830152611e8f818587611b0a565b9050611e9e6040830184611dc1565b95945050505050565b6000604082019050611ebc6000830185611aec565b611ec96020830184611bc6565b9392505050565b6000604082019050611ee56000830185611aec565b611ef26020830184611dc1565b9392505050565b6000602082019050611f0e6000830184611afb565b92915050565b60006020820190508181036000830152611f2e8184611b5c565b905092915050565b6000602082019050611f4b6000830184611bd5565b92915050565b60006020820190508181036000830152611f6b8184611be4565b905092915050565b60006020820190508181036000830152611f8c81611c1d565b9050919050565b60006020820190508181036000830152611fac81611c40565b9050919050565b60006020820190508181036000830152611fcc81611c63565b9050919050565b60006020820190508181036000830152611fec81611c86565b9050919050565b6000602082019050818103600083015261200c81611ca9565b9050919050565b6000602082019050818103600083015261202c81611ccc565b9050919050565b6000602082019050818103600083015261204c81611cef565b9050919050565b6000602082019050818103600083015261206c81611d12565b9050919050565b6000602082019050818103600083015261208c81611d35565b9050919050565b600060208201905081810360008301526120ac81611d7b565b9050919050565b600060208201905081810360008301526120cc81611d9e565b9050919050565b60006040820190506120e86000830186611dc1565b81810360208301526120fb818486611b0a565b9050949350505050565b600061210f612120565b905061211b8282612263565b919050565b6000604051905090565b600067ffffffffffffffff82111561214557612144612294565b5b61214e826122e1565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b60006121a9826121c6565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612208826121e6565b9050919050565b600061221a826121f0565b9050919050565b82818337600083830152505050565b60005b8381101561224e578082015181840152602081019050612233565b8381111561225d576000848401525b50505050565b61226c826122e1565b810181811067ffffffffffffffff8211171561228b5761228a612294565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b6126178161219e565b811461262257600080fd5b50565b61262e816121b0565b811461263957600080fd5b50565b612645816121bc565b811461265057600080fd5b50565b61265c816121e6565b811461266757600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a264697066735822122090b54815b4776f2351e1403882792d72cd8332b603e82a98ec3991bea2adcf2c64736f6c63430008070033"; + +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/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index 6fb60d1c..d00427f1 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -3,7 +3,7 @@ /* 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 { 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/index.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts index d3a5c88a..1b765f1f 100644 --- a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts @@ -1,4 +1,4 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export { IGateway__factory } from "./IGateway__factory"; +export { IGatewayEVM__factory } from "./IGatewayEVM__factory"; 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 90484cc7..8cf703c2 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -158,12 +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 { Gateway } from "./contracts/prototypes/evm/Gateway"; -export { Gateway__factory } from "./factories/contracts/prototypes/evm/Gateway__factory"; -export type { GatewayUpgradeTest } from "./contracts/prototypes/evm/GatewayUpgradeTest"; -export { GatewayUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayUpgradeTest__factory"; -export type { IGateway } from "./contracts/prototypes/evm/interfaces.sol/IGateway"; -export { IGateway__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGateway__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"; From 809b93237ea37fe7cbf510b382b7e0d111bd9c1a Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 24 Jun 2024 22:46:27 +0200 Subject: [PATCH 14/25] pr comments --- contracts/prototypes/evm/GatewayEVM.sol | 10 +++++----- contracts/prototypes/evm/GatewayEVMUpgradeTest.sol | 10 +++++----- .../prototypes/evm/gatewayevm.sol/gatewayevm.go | 2 +- .../gatewayevmupgradetest.sol/gatewayevmupgradetest.go | 2 +- test/prototypes/GatewayIntegration.spec.ts | 6 +++--- .../prototypes/evm/GatewayEVMUpgradeTest__factory.ts | 2 +- .../contracts/prototypes/evm/GatewayEVM__factory.ts | 2 +- 7 files changed, 17 insertions(+), 17 deletions(-) diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index aa7a0780..ca87eff6 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -87,26 +87,26 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { return result; } - // Tranfer specified token amount to ERC20Custody and emits event + // 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(msg.sender, recipient, token, amount); } - // Tranfer specified ETH amount to TSS address and emits event + // Transfer specified ETH amount to TSS address and emits event function send(bytes calldata recipient, uint256 amount) external payable { - if (msg.value < amount) { + if (msg.value == 0) { revert InsufficientETHAmount(); } - (bool sent, ) = tssAddress.call{value: amount}(""); + (bool sent, ) = tssAddress.call{value: msg.value}(""); if (sent == false) { revert SendFailed(); } - emit Send(msg.sender, recipient, amount); + emit Send(msg.sender, recipient, msg.value); } function setCustody(address _custody) external { diff --git a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index 81dc6a4e..db493931 100644 --- a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -88,26 +88,26 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade return result; } - // Tranfer specified token amount to ERC20Custody and emits event + // 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); } - // Tranfer specified ETH amount to TSS address and emits event + // Transfer specified ETH amount to TSS address and emits event function send(bytes calldata recipient, uint256 amount) external payable { - if (msg.value < amount) { + if (msg.value == 0) { revert InsufficientETHAmount(); } - (bool sent, ) = tssAddress.call{value: amount}(""); + (bool sent, ) = tssAddress.call{value: msg.value}(""); if (sent == false) { revert SendFailed(); } - emit Send(recipient, amount); + emit Send(recipient, msg.value); } function setCustody(address _custody) external { diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index 7536d9b2..08c69c1c 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\":\"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\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"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\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"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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", + 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 d5f68a44..2e29df28 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\":\"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\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMUpgradeTestABI is the input ABI used to generate the binding from. diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index d98bf489..55d18ce9 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -187,12 +187,12 @@ describe("GatewayEVM inbound", function () { await expect(tx).to.emit(gateway, "Send").withArgs(owner.address, destination.address.toLowerCase(), amount); }); - it("should fail to send to tss address if msg.value lower than amount", async function () { - const amount = ethers.utils.parseEther("100") as BigNumber; + it("should fail to send to tss address if msg.value is 0", async function () { + const amount = ethers.utils.parseEther("0") as BigNumber; const tssAddressBalanceBefore = (await ethers.provider.getBalance(tssAddress.address)) as BigNumber; - await expect(gateway.send(destination.address, amount, { value: amount.sub(1) })).to.be.revertedWith( + await expect(gateway.send(destination.address, amount, { value: amount })).to.be.revertedWith( "InsufficientETHAmount" ); diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts index db594578..c6014925 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -438,7 +438,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 ff008449..94d91ce4 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -450,7 +450,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c6126c8620002436000396000818161038701528181610416015281816105100152818161059f015261093b01526126c86000f3fe6080604052600436106100dd5760003560e01c80638da5cb5b1161007f578063c4d66de811610059578063c4d66de814610271578063cb0271ed1461029a578063dda79b75146102c3578063f2fde38b146102ee576100dd565b80638da5cb5b146102015780639372c4ab1461022c578063ae7a3a6f14610248576100dd565b80635131ab59116100bb5780635131ab591461015757806352d1902d146101945780635b112591146101bf578063715018a6146101ea576100dd565b80631cff79cd146100e25780633659cfe6146101125780634f1ef2861461013b575b600080fd5b6100fc60048036038101906100f791906118d6565b610317565b6040516101099190611f15565b60405180910390f35b34801561011e57600080fd5b5061013960048036038101906101349190611821565b610385565b005b61015560048036038101906101509190611936565b61050e565b005b34801561016357600080fd5b5061017e6004803603810190610179919061184e565b61064b565b60405161018b9190611f15565b60405180910390f35b3480156101a057600080fd5b506101a9610937565b6040516101b69190611efa565b60405180910390f35b3480156101cb57600080fd5b506101d46109f0565b6040516101e19190611e16565b60405180910390f35b3480156101f657600080fd5b506101ff610a16565b005b34801561020d57600080fd5b50610216610a2a565b6040516102239190611e16565b60405180910390f35b61024660048036038101906102419190611a60565b610a54565b005b34801561025457600080fd5b5061026f600480360381019061026a9190611821565b610b9f565b005b34801561027d57600080fd5b5061029860048036038101906102939190611821565b610be3565b005b3480156102a657600080fd5b506102c160048036038101906102bc91906119ec565b610d6b565b005b3480156102cf57600080fd5b506102d8610e77565b6040516102e59190611e16565b60405180910390f35b3480156102fa57600080fd5b5061031560048036038101906103109190611821565b610e9d565b005b60606000610326858585610f21565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f348686604051610372939291906120d4565b60405180910390a2809150509392505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610414576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161040b90611f94565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610453610fd8565b73ffffffffffffffffffffffffffffffffffffffff16146104a9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104a090611fb4565b60405180910390fd5b6104b28161102f565b61050b81600067ffffffffffffffff8111156104d1576104d0612295565b5b6040519080825280601f01601f1916602001820160405280156105035781602001600182028036833780820191505090505b50600061103a565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16141561059d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161059490611f94565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166105dc610fd8565b73ffffffffffffffffffffffffffffffffffffffff1614610632576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161062990611fb4565b60405180910390fd5b61063b8261102f565b6106478282600161103a565b5050565b60608573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b8152600401610688929190611ed1565b602060405180830381600087803b1580156106a257600080fd5b505af11580156106b6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106da9190611992565b5060006106e8868585610f21565b90508673ffffffffffffffffffffffffffffffffffffffff1663095ea7b38760006040518363ffffffff1660e01b8152600401610726929190611ea8565b602060405180830381600087803b15801561074057600080fd5b505af1158015610754573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107789190611992565b5060008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016107b49190611e16565b60206040518083038186803b1580156107cc57600080fd5b505afa1580156107e0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108049190611ac0565b905060008111156108c0578773ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff1660e01b815260040161086c929190611ed1565b602060405180830381600087803b15801561088657600080fd5b505af115801561089a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108be9190611992565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610921939291906120d4565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16146109c7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109be90611fd4565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610a1e6111b7565b610a286000611235565b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6000341415610a8f576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1634604051610ad790611e01565b60006040518083038185875af1925050503d8060008114610b14576040519150601f19603f3d011682016040523d82523d6000602084013e610b19565b606091505b50509050600015158115151415610b5c576040517f81063e5100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f84583322b159855a8990ae36b9708ebcb1d1c7fdccf3cd41e19e4f65f00bb2b633858534604051610b919493929190611e68565b60405180910390a150505050565b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610c145750600160008054906101000a900460ff1660ff16105b80610c415750610c23306112fb565b158015610c405750600160008054906101000a900460ff1660ff16145b5b610c80576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c7790612014565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610cbd576001600060016101000a81548160ff0219169083151502179055505b610cc561131e565b610ccd611377565b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508015610d675760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610d5e9190611f37565b60405180910390a15b5050565b8173ffffffffffffffffffffffffffffffffffffffff166323b872dd3360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b8152600401610dca93929190611e31565b602060405180830381600087803b158015610de457600080fd5b505af1158015610df8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e1c9190611992565b508173ffffffffffffffffffffffffffffffffffffffff167ff31c5882db91f6b727bb3fe49d02ca7e0e036d99bd5f6bb64cb0c8d9f74f991133868685604051610e699493929190611e68565b60405180910390a250505050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610ea56111b7565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610f15576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f0c90611f74565b60405180910390fd5b610f1e81611235565b50565b60606000808573ffffffffffffffffffffffffffffffffffffffff16348686604051610f4e929190611dd1565b60006040518083038185875af1925050503d8060008114610f8b576040519150601f19603f3d011682016040523d82523d6000602084013e610f90565b606091505b509150915081610fcc576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006110067f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c8565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6110376111b7565b50565b6110667f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6113d2565b60000160009054906101000a900460ff161561108a57611085836113dc565b6111b2565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110d057600080fd5b505afa92505050801561110157506040513d601f19601f820116820180604052508101906110fe91906119bf565b60015b611140576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161113790612034565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b81146111a5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161119c90611ff4565b60405180910390fd5b506111b1838383611495565b5b505050565b6111bf6114c1565b73ffffffffffffffffffffffffffffffffffffffff166111dd610a2a565b73ffffffffffffffffffffffffffffffffffffffff1614611233576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161122a90612074565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff1661136d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611364906120b4565b60405180910390fd5b6113756114c9565b565b600060019054906101000a900460ff166113c6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113bd906120b4565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6113e5816112fb565b611424576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161141b90612054565b60405180910390fd5b806114517f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6113c8565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b61149e8361152a565b6000825111806114ab5750805b156114bc576114ba8383611579565b505b505050565b600033905090565b600060019054906101000a900460ff16611518576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150f906120b4565b60405180910390fd5b6115286115236114c1565b611235565b565b611533816113dc565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b606061159e838360405180606001604052806027815260200161266c602791396115a6565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516115d09190611dea565b600060405180830381855af49150503d806000811461160b576040519150601f19603f3d011682016040523d82523d6000602084013e611610565b606091505b50915091506116218683838761162c565b925050509392505050565b6060831561168f5760008351141561168757611647856112fb565b611686576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161167d90612094565b60405180910390fd5b5b82905061169a565b61169983836116a2565b5b949350505050565b6000825111156116b55781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116e99190611f52565b60405180910390fd5b60006117056117008461212b565b612106565b905082815260208101848484011115611721576117206122d3565b5b61172c848285612222565b509392505050565b6000813590506117438161260f565b92915050565b60008151905061175881612626565b92915050565b60008151905061176d8161263d565b92915050565b60008083601f840112611789576117886122c9565b5b8235905067ffffffffffffffff8111156117a6576117a56122c4565b5b6020830191508360018202830111156117c2576117c16122ce565b5b9250929050565b600082601f8301126117de576117dd6122c9565b5b81356117ee8482602086016116f2565b91505092915050565b60008135905061180681612654565b92915050565b60008151905061181b81612654565b92915050565b600060208284031215611837576118366122dd565b5b600061184584828501611734565b91505092915050565b60008060008060006080868803121561186a576118696122dd565b5b600061187888828901611734565b955050602061188988828901611734565b945050604061189a888289016117f7565b935050606086013567ffffffffffffffff8111156118bb576118ba6122d8565b5b6118c788828901611773565b92509250509295509295909350565b6000806000604084860312156118ef576118ee6122dd565b5b60006118fd86828701611734565b935050602084013567ffffffffffffffff81111561191e5761191d6122d8565b5b61192a86828701611773565b92509250509250925092565b6000806040838503121561194d5761194c6122dd565b5b600061195b85828601611734565b925050602083013567ffffffffffffffff81111561197c5761197b6122d8565b5b611988858286016117c9565b9150509250929050565b6000602082840312156119a8576119a76122dd565b5b60006119b684828501611749565b91505092915050565b6000602082840312156119d5576119d46122dd565b5b60006119e38482850161175e565b91505092915050565b60008060008060608587031215611a0657611a056122dd565b5b600085013567ffffffffffffffff811115611a2457611a236122d8565b5b611a3087828801611773565b94509450506020611a4387828801611734565b9250506040611a54878288016117f7565b91505092959194509250565b600080600060408486031215611a7957611a786122dd565b5b600084013567ffffffffffffffff811115611a9757611a966122d8565b5b611aa386828701611773565b93509350506020611ab6868287016117f7565b9150509250925092565b600060208284031215611ad657611ad56122dd565b5b6000611ae48482850161180c565b91505092915050565b611af68161219f565b82525050565b611b05816121bd565b82525050565b6000611b178385612172565b9350611b24838584612222565b611b2d836122e2565b840190509392505050565b6000611b448385612183565b9350611b51838584612222565b82840190509392505050565b6000611b688261215c565b611b728185612172565b9350611b82818560208601612231565b611b8b816122e2565b840191505092915050565b6000611ba18261215c565b611bab8185612183565b9350611bbb818560208601612231565b80840191505092915050565b611bd0816121fe565b82525050565b611bdf81612210565b82525050565b6000611bf082612167565b611bfa818561218e565b9350611c0a818560208601612231565b611c13816122e2565b840191505092915050565b6000611c2b60268361218e565b9150611c36826122f3565b604082019050919050565b6000611c4e602c8361218e565b9150611c5982612342565b604082019050919050565b6000611c71602c8361218e565b9150611c7c82612391565b604082019050919050565b6000611c9460388361218e565b9150611c9f826123e0565b604082019050919050565b6000611cb760298361218e565b9150611cc28261242f565b604082019050919050565b6000611cda602e8361218e565b9150611ce58261247e565b604082019050919050565b6000611cfd602e8361218e565b9150611d08826124cd565b604082019050919050565b6000611d20602d8361218e565b9150611d2b8261251c565b604082019050919050565b6000611d4360208361218e565b9150611d4e8261256b565b602082019050919050565b6000611d66600083612183565b9150611d7182612594565b600082019050919050565b6000611d89601d8361218e565b9150611d9482612597565b602082019050919050565b6000611dac602b8361218e565b9150611db7826125c0565b604082019050919050565b611dcb816121e7565b82525050565b6000611dde828486611b38565b91508190509392505050565b6000611df68284611b96565b915081905092915050565b6000611e0c82611d59565b9150819050919050565b6000602082019050611e2b6000830184611aed565b92915050565b6000606082019050611e466000830186611aed565b611e536020830185611aed565b611e606040830184611dc2565b949350505050565b6000606082019050611e7d6000830187611aed565b8181036020830152611e90818587611b0b565b9050611e9f6040830184611dc2565b95945050505050565b6000604082019050611ebd6000830185611aed565b611eca6020830184611bc7565b9392505050565b6000604082019050611ee66000830185611aed565b611ef36020830184611dc2565b9392505050565b6000602082019050611f0f6000830184611afc565b92915050565b60006020820190508181036000830152611f2f8184611b5d565b905092915050565b6000602082019050611f4c6000830184611bd6565b92915050565b60006020820190508181036000830152611f6c8184611be5565b905092915050565b60006020820190508181036000830152611f8d81611c1e565b9050919050565b60006020820190508181036000830152611fad81611c41565b9050919050565b60006020820190508181036000830152611fcd81611c64565b9050919050565b60006020820190508181036000830152611fed81611c87565b9050919050565b6000602082019050818103600083015261200d81611caa565b9050919050565b6000602082019050818103600083015261202d81611ccd565b9050919050565b6000602082019050818103600083015261204d81611cf0565b9050919050565b6000602082019050818103600083015261206d81611d13565b9050919050565b6000602082019050818103600083015261208d81611d36565b9050919050565b600060208201905081810360008301526120ad81611d7c565b9050919050565b600060208201905081810360008301526120cd81611d9f565b9050919050565b60006040820190506120e96000830186611dc2565b81810360208301526120fc818486611b0b565b9050949350505050565b6000612110612121565b905061211c8282612264565b919050565b6000604051905090565b600067ffffffffffffffff82111561214657612145612295565b5b61214f826122e2565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b60006121aa826121c7565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612209826121e7565b9050919050565b600061221b826121f1565b9050919050565b82818337600083830152505050565b60005b8381101561224f578082015181840152602081019050612234565b8381111561225e576000848401525b50505050565b61226d826122e2565b810181811067ffffffffffffffff8211171561228c5761228b612295565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b6126188161219f565b811461262357600080fd5b50565b61262f816121b1565b811461263a57600080fd5b50565b612646816121bd565b811461265157600080fd5b50565b61265d816121e7565b811461266857600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220ea1799872442b30dbe6690f698427118dc3ef24baf52729719a1766515b7cfca64736f6c63430008070033"; type GatewayEVMConstructorParams = | [signer?: Signer] From fdaf4b110ad80bf300166d86dfe7be61da1d2a0f Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 24 Jun 2024 22:50:36 +0200 Subject: [PATCH 15/25] extend upgrade test --- test/prototypes/GatewayUpgrade.spec.ts | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/test/prototypes/GatewayUpgrade.spec.ts b/test/prototypes/GatewayUpgrade.spec.ts index a11c1fc6..8482ac52 100644 --- a/test/prototypes/GatewayUpgrade.spec.ts +++ b/test/prototypes/GatewayUpgrade.spec.ts @@ -35,6 +35,9 @@ describe("GatewayEVM 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("GatewayEVMUpgradeTest", randomSigner); @@ -44,6 +47,7 @@ describe("GatewayEVM upgrade", function () { // Upgrade with owner account GatewayUpgradeTest = await ethers.getContractFactory("GatewayEVMUpgradeTest", owner); + const gatewayUpgradeTest = await upgrades.upgradeProxy(gateway.address, GatewayUpgradeTest); // Forward call @@ -62,5 +66,9 @@ describe("GatewayEVM upgrade", function () { // 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); }); }); From 75fd6b4819c0cf9388df593fc21d2ec434b67787 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 18:28:30 +0200 Subject: [PATCH 16/25] use new inbound interface and add tests --- contracts/prototypes/evm/GatewayEVM.sol | 57 ++- test/prototypes/GatewayIntegration.spec.ts | 95 ++++- .../contracts/prototypes/evm/GatewayEVM.ts | 401 ++++++++++++------ .../prototypes/evm/GatewayEVM__factory.ts | 226 ++++++---- 4 files changed, 539 insertions(+), 240 deletions(-) diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index ca87eff6..9d666122 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -11,16 +11,17 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; // The contract doesn't hold any funds and should never have active allowances contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { error ExecutionFailed(); - error SendFailed(); + error DepositFailed(); error InsufficientETHAmount(); + error InsufficientERC20Amount(); 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 SendERC20(address sender, bytes recipient, address indexed asset, uint256 amount); - event Send(address sender, bytes recipient, uint256 amount); + 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() { @@ -87,26 +88,50 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { 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(msg.sender, recipient, token, amount); - } + // Deposit ETH + function deposit(address receiver) external payable { + if (msg.value == 0) revert InsufficientETHAmount(); + (bool deposited, ) = tssAddress.call{value: msg.value}(""); - // 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(); + if (deposited == false) { + revert DepositFailed(); } + + emit Deposit(msg.sender, receiver, msg.value, address(0), ""); + } + + // Deposit ERC20 tokens + 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, ""); + } - (bool sent, ) = tssAddress.call{value: msg.value}(""); + // Deposit ETH 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 (sent == false) { - revert SendFailed(); + if (deposited == false) { + revert DepositFailed(); } + + emit Deposit(msg.sender, receiver, msg.value, address(0), payload); + } + + // Deposit ERC20 tokens 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); + } - emit Send(msg.sender, 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 { diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 55d18ce9..aaeb1fb3 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -151,7 +151,7 @@ describe("GatewayEVM inbound", function () { await token.mint(owner.address, ethers.utils.parseEther("1000")); }); - it("should send erc20 to custody and emit event", async function () { + it("should deposit erc20 to custody and emit event", async function () { const amount = ethers.utils.parseEther("100"); const custodyBalanceBefore = await token.balanceOf(custody.address); @@ -159,7 +159,7 @@ describe("GatewayEVM inbound", function () { await token.approve(gateway.address, amount); - const tx = await gateway.sendERC20(destination.address, token.address, amount); + const tx = await gateway["deposit(address,uint256,address)"](destination.address, amount, token.address); await tx.wait(); const custodyBalanceAfter = await token.balanceOf(custody.address); @@ -169,34 +169,101 @@ describe("GatewayEVM inbound", function () { expect(ownerBalanceAfter).to.equal(ethers.utils.parseEther("900")); await expect(tx) - .to.emit(gateway, "SendERC20") - .withArgs(owner.address, destination.address.toLowerCase(), token.address, amount); + .to.emit(gateway, "Deposit") + .withArgs(ethers.utils.getAddress(owner.address), ethers.utils.getAddress(destination.address), amount, ethers.utils.getAddress(token.address), "0x"); }); - it("should send eth to tss address and emit event", async function () { - const amount = ethers.utils.parseEther("100") as BigNumber; + 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.send(destination.address, amount, { value: amount }); + const tx = await gateway["deposit(address)"](destination.address, { value: amount }); await tx.wait(); const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); - await expect(tx).to.emit(gateway, "Send").withArgs(owner.address, destination.address.toLowerCase(), 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 send to tss address if msg.value is 0", async function () { - const amount = ethers.utils.parseEther("0") as BigNumber; + 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 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; - await expect(gateway.send(destination.address, amount, { value: amount })).to.be.revertedWith( - "InsufficientETHAmount" - ); + const tx = await gateway["depositAndCall(address,bytes)"](destination.address, payload, { value: amount }); + await tx.wait(); const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); - expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore); + 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 tx.wait(); + + await expect(tx) + .to.emit(gateway, "Call") + .withArgs(ethers.utils.getAddress(owner.address), ethers.utils.getAddress(destination.address), payload); }); }); diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts index 652f4914..45ca3f7f 100644 --- a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts +++ b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts @@ -30,15 +30,18 @@ import type { 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; - "send(bytes,uint256)": FunctionFragment; - "sendERC20(bytes,address,uint256)": FunctionFragment; "setCustody(address)": FunctionFragment; "transferOwnership(address)": FunctionFragment; "tssAddress()": FunctionFragment; @@ -48,15 +51,18 @@ export interface GatewayEVMInterface extends utils.Interface { 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" | "setCustody" | "transferOwnership" | "tssAddress" @@ -64,7 +70,36 @@ export interface GatewayEVMInterface extends utils.Interface { | "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] @@ -91,18 +126,6 @@ export interface GatewayEVMInterface 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] @@ -124,7 +147,24 @@ export interface GatewayEVMInterface extends utils.Interface { 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", @@ -140,8 +180,6 @@ export interface GatewayEVMInterface 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", @@ -157,23 +195,23 @@ export interface GatewayEVMInterface extends utils.Interface { 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; - "Send(address,bytes,uint256)": EventFragment; - "SendERC20(address,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: "ExecutedWithERC20"): EventFragment; getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; - getEvent(nameOrSignatureOrTopic: "Send"): EventFragment; - getEvent(nameOrSignatureOrTopic: "SendERC20"): EventFragment; getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; } @@ -198,6 +236,29 @@ 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; @@ -243,31 +304,6 @@ export type OwnershipTransferredEvent = TypedEvent< export type OwnershipTransferredEventFilter = TypedEventFilter; -export interface SendEventObject { - sender: string; - recipient: string; - amount: BigNumber; -} -export type SendEvent = TypedEvent< - [string, string, BigNumber], - SendEventObject ->; - -export type SendEventFilter = TypedEventFilter; - -export interface SendERC20EventObject { - sender: string; - recipient: string; - asset: string; - amount: BigNumber; -} -export type SendERC20Event = TypedEvent< - [string, string, string, BigNumber], - SendERC20EventObject ->; - -export type SendERC20EventFilter = TypedEventFilter; - export interface UpgradedEventObject { implementation: string; } @@ -302,8 +338,40 @@ export interface GatewayEVM 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, @@ -331,19 +399,6 @@ export interface GatewayEVM 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 } @@ -368,8 +423,40 @@ export interface GatewayEVM extends BaseContract { ): 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, @@ -397,19 +484,6 @@ export interface GatewayEVM 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 } @@ -434,8 +508,40 @@ export interface GatewayEVM extends BaseContract { ): 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, @@ -461,19 +567,6 @@ export interface GatewayEVM 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 @@ -515,6 +608,32 @@ export interface GatewayEVM 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, @@ -551,26 +670,6 @@ export interface GatewayEVM extends BaseContract { newOwner?: PromiseOrValue | null ): OwnershipTransferredEventFilter; - "Send(address,bytes,uint256)"( - sender?: null, - recipient?: null, - amount?: null - ): SendEventFilter; - Send(sender?: null, recipient?: null, amount?: null): SendEventFilter; - - "SendERC20(address,bytes,address,uint256)"( - sender?: null, - recipient?: null, - asset?: PromiseOrValue | null, - amount?: null - ): SendERC20EventFilter; - SendERC20( - sender?: null, - recipient?: null, - asset?: PromiseOrValue | null, - amount?: null - ): SendERC20EventFilter; - "Upgraded(address)"( implementation?: PromiseOrValue | null ): UpgradedEventFilter; @@ -580,8 +679,40 @@ export interface GatewayEVM 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, @@ -609,19 +740,6 @@ export interface GatewayEVM 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 } @@ -647,8 +765,40 @@ export interface GatewayEVM extends BaseContract { }; 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, @@ -676,19 +826,6 @@ export interface GatewayEVM 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 } diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index 94d91ce4..fa975c82 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: "DepositFailed", + type: "error", + }, { inputs: [], name: "ExecutionFailed", @@ -22,12 +27,12 @@ const _abi = [ }, { inputs: [], - name: "InsufficientETHAmount", + name: "InsufficientERC20Amount", type: "error", }, { inputs: [], - name: "SendFailed", + name: "InsufficientETHAmount", type: "error", }, { @@ -62,6 +67,68 @@ 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: [ @@ -154,82 +221,126 @@ const _abi = [ anonymous: false, inputs: [ { - indexed: false, + indexed: true, internalType: "address", - name: "sender", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", type: "address", }, { - indexed: false, 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: "address", - name: "sender", + name: "receiver", type: "address", }, + ], + name: "deposit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ { - indexed: false, - internalType: "bytes", - name: "recipient", - type: "bytes", - }, - { - 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", }, { @@ -336,47 +447,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: "token", - type: "address", - }, - { - internalType: "uint256", - name: "amount", - type: "uint256", - }, - ], - name: "sendERC20", - outputs: [], - stateMutability: "nonpayable", - type: "function", - }, { inputs: [ { @@ -450,7 +520,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] From 261ab5beed3765cb90c52305903c3682530de7e5 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 18:29:35 +0200 Subject: [PATCH 17/25] generate --- .../evm/gatewayevm.sol/gatewayevm.go | 608 ++++++++++-------- test/prototypes/GatewayIntegration.spec.ts | 68 +- 2 files changed, 390 insertions(+), 286 deletions(-) diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index 08c69c1c..e6b2a072 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\":\"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\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"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\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"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\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"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. @@ -326,6 +326,111 @@ 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) @@ -410,48 +515,6 @@ func (_GatewayEVM *GatewayEVMTransactorSession) RenounceOwnership() (*types.Tran return _GatewayEVM.Contract.RenounceOwnership(&_GatewayEVM.TransactOpts) } -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_GatewayEVM *GatewayEVMTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVM.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 (_GatewayEVM *GatewayEVMSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVM.Contract.Send(&_GatewayEVM.TransactOpts, recipient, amount) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_GatewayEVM *GatewayEVMTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVM.Contract.Send(&_GatewayEVM.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 (_GatewayEVM *GatewayEVMTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVM.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 (_GatewayEVM *GatewayEVMSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVM.Contract.SendERC20(&_GatewayEVM.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 (_GatewayEVM *GatewayEVMTransactorSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVM.Contract.SendERC20(&_GatewayEVM.TransactOpts, recipient, token, amount) -} - // SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. // // Solidity: function setCustody(address _custody) returns() @@ -815,9 +878,9 @@ func (_GatewayEVM *GatewayEVMFilterer) ParseBeaconUpgraded(log types.Log) (*Gate 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 +// 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 @@ -831,7 +894,7 @@ type GatewayEVMExecutedIterator 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 *GatewayEVMExecutedIterator) Next() bool { +func (it *GatewayEVMCallIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -840,7 +903,7 @@ func (it *GatewayEVMExecutedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMExecuted) + it.Event = new(GatewayEVMCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -855,7 +918,7 @@ func (it *GatewayEVMExecutedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMExecuted) + it.Event = new(GatewayEVMCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -871,53 +934,61 @@ func (it *GatewayEVMExecutedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMExecutedIterator) Error() error { +func (it *GatewayEVMCallIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMExecutedIterator) Close() error { +func (it *GatewayEVMCallIterator) 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 +// 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 } -// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// FilterCall is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_GatewayEVM *GatewayEVMFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMExecutedIterator, error) { +// 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 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 := _GatewayEVM.contract.FilterLogs(opts, "Executed", destinationRule) + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Call", senderRule, receiverRule) if err != nil { return nil, err } - return &GatewayEVMExecutedIterator{contract: _GatewayEVM.contract, event: "Executed", logs: logs, sub: sub}, nil + return &GatewayEVMCallIterator{contract: _GatewayEVM.contract, event: "Call", logs: logs, sub: sub}, nil } -// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// WatchCall is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // -// 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) { +// 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 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 := _GatewayEVM.contract.WatchLogs(opts, "Executed", destinationRule) + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Call", senderRule, receiverRule) if err != nil { return nil, err } @@ -927,8 +998,8 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchExecuted(opts *bind.WatchOpts, sink 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 { + event := new(GatewayEVMCall) + if err := _GatewayEVM.contract.UnpackLog(event, "Call", log); err != nil { return err } event.Raw = log @@ -949,21 +1020,21 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchExecuted(opts *bind.WatchOpts, sink }), nil } -// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// ParseCall is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // -// 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 { +// 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 } -// 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 +// 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 @@ -977,7 +1048,7 @@ type GatewayEVMExecutedWithERC20Iterator 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 *GatewayEVMExecutedWithERC20Iterator) Next() bool { +func (it *GatewayEVMDepositIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -986,7 +1057,7 @@ func (it *GatewayEVMExecutedWithERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMExecutedWithERC20) + it.Event = new(GatewayEVMDeposit) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1001,7 +1072,7 @@ func (it *GatewayEVMExecutedWithERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMExecutedWithERC20) + it.Event = new(GatewayEVMDeposit) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1017,62 +1088,63 @@ func (it *GatewayEVMExecutedWithERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMExecutedWithERC20Iterator) Error() error { +func (it *GatewayEVMDepositIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMExecutedWithERC20Iterator) Close() error { +func (it *GatewayEVMDepositIterator) 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 +// 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 } -// 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 (_GatewayEVM *GatewayEVMFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMExecutedWithERC20Iterator, error) { +// 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 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 := _GatewayEVM.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) if err != nil { return nil, err } - return &GatewayEVMExecutedWithERC20Iterator{contract: _GatewayEVM.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil + return &GatewayEVMDepositIterator{contract: _GatewayEVM.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 (_GatewayEVM *GatewayEVMFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMExecutedWithERC20, 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 (_GatewayEVM *GatewayEVMFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayEVMDeposit, 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 := _GatewayEVM.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) if err != nil { return nil, err } @@ -1082,8 +1154,8 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchExecutedWithERC20(opts *bind.WatchOp 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 { + event := new(GatewayEVMDeposit) + if err := _GatewayEVM.contract.UnpackLog(event, "Deposit", log); err != nil { return err } event.Raw = log @@ -1104,21 +1176,21 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchExecutedWithERC20(opts *bind.WatchOp }), 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 (_GatewayEVM *GatewayEVMFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMExecutedWithERC20, error) { - event := new(GatewayEVMExecutedWithERC20) - if err := _GatewayEVM.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { +// 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 } -// 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 +// 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 @@ -1132,7 +1204,7 @@ type GatewayEVMInitializedIterator 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 *GatewayEVMInitializedIterator) Next() bool { +func (it *GatewayEVMExecutedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1141,7 +1213,7 @@ func (it *GatewayEVMInitializedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMInitialized) + it.Event = new(GatewayEVMExecuted) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1156,7 +1228,7 @@ func (it *GatewayEVMInitializedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMInitialized) + it.Event = new(GatewayEVMExecuted) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1172,41 +1244,53 @@ func (it *GatewayEVMInitializedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMInitializedIterator) Error() error { +func (it *GatewayEVMExecutedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMInitializedIterator) Close() error { +func (it *GatewayEVMExecutedIterator) 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 +// 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 } -// 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 (_GatewayEVM *GatewayEVMFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMInitializedIterator, error) { +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVM *GatewayEVMFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMExecutedIterator, error) { - logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Initialized") + 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 &GatewayEVMInitializedIterator{contract: _GatewayEVM.contract, event: "Initialized", logs: logs, sub: sub}, nil + return &GatewayEVMExecutedIterator{contract: _GatewayEVM.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 (_GatewayEVM *GatewayEVMFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayEVMInitialized) (event.Subscription, error) { +// 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) { - logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Initialized") + 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 } @@ -1216,8 +1300,8 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchInitialized(opts *bind.WatchOpts, si 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 { + event := new(GatewayEVMExecuted) + if err := _GatewayEVM.contract.UnpackLog(event, "Executed", log); err != nil { return err } event.Raw = log @@ -1238,21 +1322,21 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchInitialized(opts *bind.WatchOpts, si }), 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 (_GatewayEVM *GatewayEVMFilterer) ParseInitialized(log types.Log) (*GatewayEVMInitialized, error) { - event := new(GatewayEVMInitialized) - if err := _GatewayEVM.contract.UnpackLog(event, "Initialized", log); err != nil { +// 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 } -// 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 +// 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 @@ -1266,7 +1350,7 @@ type GatewayEVMOwnershipTransferredIterator 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 *GatewayEVMOwnershipTransferredIterator) Next() bool { +func (it *GatewayEVMExecutedWithERC20Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1275,7 +1359,7 @@ func (it *GatewayEVMOwnershipTransferredIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMOwnershipTransferred) + it.Event = new(GatewayEVMExecutedWithERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1290,7 +1374,7 @@ func (it *GatewayEVMOwnershipTransferredIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMOwnershipTransferred) + it.Event = new(GatewayEVMExecutedWithERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1306,60 +1390,62 @@ func (it *GatewayEVMOwnershipTransferredIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMOwnershipTransferredIterator) Error() error { +func (it *GatewayEVMExecutedWithERC20Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMOwnershipTransferredIterator) Close() error { +func (it *GatewayEVMExecutedWithERC20Iterator) 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 +// 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 } -// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayEVM *GatewayEVMFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayEVMOwnershipTransferredIterator, error) { +// 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 previousOwnerRule []interface{} - for _, previousOwnerItem := range previousOwner { - previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) } - var newOwnerRule []interface{} - for _, newOwnerItem := range newOwner { - newOwnerRule = append(newOwnerRule, newOwnerItem) + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) } - logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } - return &GatewayEVMOwnershipTransferredIterator{contract: _GatewayEVM.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil + return &GatewayEVMExecutedWithERC20Iterator{contract: _GatewayEVM.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil } -// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // -// 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) { +// 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 previousOwnerRule []interface{} - for _, previousOwnerItem := range previousOwner { - previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) } - var newOwnerRule []interface{} - for _, newOwnerItem := range newOwner { - newOwnerRule = append(newOwnerRule, newOwnerItem) + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) } - logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } @@ -1369,8 +1455,8 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchOwnershipTransferred(opts *bind.Watc 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 { + event := new(GatewayEVMExecutedWithERC20) + if err := _GatewayEVM.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return err } event.Raw = log @@ -1391,21 +1477,21 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchOwnershipTransferred(opts *bind.Watc }), 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 (_GatewayEVM *GatewayEVMFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayEVMOwnershipTransferred, error) { - event := new(GatewayEVMOwnershipTransferred) - if err := _GatewayEVM.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { +// 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 } -// GatewayEVMSendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the GatewayEVM contract. -type GatewayEVMSendIterator struct { - Event *GatewayEVMSend // Event containing the contract specifics and raw log +// 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 @@ -1419,7 +1505,7 @@ type GatewayEVMSendIterator 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 *GatewayEVMSendIterator) Next() bool { +func (it *GatewayEVMInitializedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1428,7 +1514,7 @@ func (it *GatewayEVMSendIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMSend) + it.Event = new(GatewayEVMInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1443,7 +1529,7 @@ func (it *GatewayEVMSendIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMSend) + it.Event = new(GatewayEVMInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1459,43 +1545,41 @@ func (it *GatewayEVMSendIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMSendIterator) Error() error { +func (it *GatewayEVMInitializedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMSendIterator) Close() error { +func (it *GatewayEVMInitializedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayEVMSend represents a Send event raised by the GatewayEVM contract. -type GatewayEVMSend struct { - Sender common.Address - Recipient []byte - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos +// GatewayEVMInitialized represents a Initialized event raised by the GatewayEVM contract. +type GatewayEVMInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos } -// FilterSend is a free log retrieval operation binding the contract event 0x84583322b159855a8990ae36b9708ebcb1d1c7fdccf3cd41e19e4f65f00bb2b6. +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: event Send(address sender, bytes recipient, uint256 amount) -func (_GatewayEVM *GatewayEVMFilterer) FilterSend(opts *bind.FilterOpts) (*GatewayEVMSendIterator, error) { +// Solidity: event Initialized(uint8 version) +func (_GatewayEVM *GatewayEVMFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMInitializedIterator, error) { - logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Send") + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Initialized") if err != nil { return nil, err } - return &GatewayEVMSendIterator{contract: _GatewayEVM.contract, event: "Send", logs: logs, sub: sub}, nil + return &GatewayEVMInitializedIterator{contract: _GatewayEVM.contract, event: "Initialized", logs: logs, sub: sub}, nil } -// WatchSend is a free log subscription operation binding the contract event 0x84583322b159855a8990ae36b9708ebcb1d1c7fdccf3cd41e19e4f65f00bb2b6. +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: event Send(address sender, bytes recipient, uint256 amount) -func (_GatewayEVM *GatewayEVMFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewayEVMSend) (event.Subscription, error) { +// 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, "Send") + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Initialized") if err != nil { return nil, err } @@ -1505,8 +1589,8 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchSend(opts *bind.WatchOpts, sink chan select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayEVMSend) - if err := _GatewayEVM.contract.UnpackLog(event, "Send", log); err != nil { + event := new(GatewayEVMInitialized) + if err := _GatewayEVM.contract.UnpackLog(event, "Initialized", log); err != nil { return err } event.Raw = log @@ -1527,21 +1611,21 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchSend(opts *bind.WatchOpts, sink chan }), nil } -// ParseSend is a log parse operation binding the contract event 0x84583322b159855a8990ae36b9708ebcb1d1c7fdccf3cd41e19e4f65f00bb2b6. +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: event Send(address sender, bytes recipient, uint256 amount) -func (_GatewayEVM *GatewayEVMFilterer) ParseSend(log types.Log) (*GatewayEVMSend, error) { - event := new(GatewayEVMSend) - if err := _GatewayEVM.contract.UnpackLog(event, "Send", log); err != nil { +// 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 } -// GatewayEVMSendERC20Iterator is returned from FilterSendERC20 and is used to iterate over the raw logs and unpacked data for SendERC20 events raised by the GatewayEVM contract. -type GatewayEVMSendERC20Iterator struct { - Event *GatewayEVMSendERC20 // Event containing the contract specifics and raw log +// 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 @@ -1555,7 +1639,7 @@ type GatewayEVMSendERC20Iterator 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 *GatewayEVMSendERC20Iterator) Next() bool { +func (it *GatewayEVMOwnershipTransferredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1564,7 +1648,7 @@ func (it *GatewayEVMSendERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMSendERC20) + it.Event = new(GatewayEVMOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1579,7 +1663,7 @@ func (it *GatewayEVMSendERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMSendERC20) + it.Event = new(GatewayEVMOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1595,54 +1679,60 @@ func (it *GatewayEVMSendERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMSendERC20Iterator) Error() error { +func (it *GatewayEVMOwnershipTransferredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMSendERC20Iterator) Close() error { +func (it *GatewayEVMOwnershipTransferredIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayEVMSendERC20 represents a SendERC20 event raised by the GatewayEVM contract. -type GatewayEVMSendERC20 struct { - Sender common.Address - Recipient []byte - Asset common.Address - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos +// 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 } -// FilterSendERC20 is a free log retrieval operation binding the contract event 0xf31c5882db91f6b727bb3fe49d02ca7e0e036d99bd5f6bb64cb0c8d9f74f9911. +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SendERC20(address sender, bytes recipient, address indexed asset, uint256 amount) -func (_GatewayEVM *GatewayEVMFilterer) FilterSendERC20(opts *bind.FilterOpts, asset []common.Address) (*GatewayEVMSendERC20Iterator, error) { +// 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 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 := _GatewayEVM.contract.FilterLogs(opts, "SendERC20", assetRule) + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } - return &GatewayEVMSendERC20Iterator{contract: _GatewayEVM.contract, event: "SendERC20", logs: logs, sub: sub}, nil + return &GatewayEVMOwnershipTransferredIterator{contract: _GatewayEVM.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil } -// WatchSendERC20 is a free log subscription operation binding the contract event 0xf31c5882db91f6b727bb3fe49d02ca7e0e036d99bd5f6bb64cb0c8d9f74f9911. +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SendERC20(address sender, bytes recipient, address indexed asset, uint256 amount) -func (_GatewayEVM *GatewayEVMFilterer) WatchSendERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMSendERC20, asset []common.Address) (event.Subscription, error) { +// 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 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 := _GatewayEVM.contract.WatchLogs(opts, "SendERC20", assetRule) + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } @@ -1652,8 +1742,8 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchSendERC20(opts *bind.WatchOpts, sink select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayEVMSendERC20) - if err := _GatewayEVM.contract.UnpackLog(event, "SendERC20", log); err != nil { + event := new(GatewayEVMOwnershipTransferred) + if err := _GatewayEVM.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return err } event.Raw = log @@ -1674,12 +1764,12 @@ func (_GatewayEVM *GatewayEVMFilterer) WatchSendERC20(opts *bind.WatchOpts, sink }), nil } -// ParseSendERC20 is a log parse operation binding the contract event 0xf31c5882db91f6b727bb3fe49d02ca7e0e036d99bd5f6bb64cb0c8d9f74f9911. +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SendERC20(address sender, bytes recipient, address indexed asset, uint256 amount) -func (_GatewayEVM *GatewayEVMFilterer) ParseSendERC20(log types.Log) (*GatewayEVMSendERC20, error) { - event := new(GatewayEVMSendERC20) - if err := _GatewayEVM.contract.UnpackLog(event, "SendERC20", log); err != nil { +// 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 diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index aaeb1fb3..f90dd14e 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -170,15 +170,22 @@ describe("GatewayEVM inbound", function () { 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"); + .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"); + 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 () { @@ -194,37 +201,41 @@ describe("GatewayEVM inbound", function () { await expect(tx) .to.emit(gateway, "Deposit") - .withArgs(ethers.utils.getAddress(owner.address), ethers.utils.getAddress(destination.address), amount, ethers.constants.AddressZero, "0x"); + .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"); + await expect(gateway["deposit(address)"](destination.address, { value: amount })).to.be.revertedWith( + "InsufficientETHAmount" + ); }); 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 ABI = ["function hello(address to)"]; let iface = new ethers.utils.Interface(ABI); - const payload = iface.encodeFunctionData("hello", [ "0x1234567890123456789012345678901234567890"]); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); - await expect(gateway["depositAndCall(address,uint256,address,bytes)"](destination.address, amount, token.address, payload)) - .to.be.revertedWith("InsufficientERC20Amount"); + 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 ABI = ["function hello(address to)"]; let iface = new ethers.utils.Interface(ABI); - const payload = iface.encodeFunctionData("hello", [ "0x1234567890123456789012345678901234567890"]); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); const tssAddressBalanceBefore = (await ethers.provider.getBalance(tssAddress.address)) as BigNumber; @@ -236,28 +247,31 @@ describe("GatewayEVM inbound", function () { await expect(tx) .to.emit(gateway, "Deposit") - .withArgs(ethers.utils.getAddress(owner.address), ethers.utils.getAddress(destination.address), amount, ethers.constants.AddressZero, payload); + .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 ABI = ["function hello(address to)"]; let iface = new ethers.utils.Interface(ABI); - const payload = iface.encodeFunctionData("hello", [ "0x1234567890123456789012345678901234567890"]); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); - await expect(gateway["depositAndCall(address,bytes)"](destination.address, payload, { value: amount })) - .to.be.revertedWith("InsufficientETHAmount"); + 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 ABI = ["function hello(address to)"]; let iface = new ethers.utils.Interface(ABI); - const payload = iface.encodeFunctionData("hello", [ "0x1234567890123456789012345678901234567890"]); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); const tx = await gateway.call(destination.address, payload); await tx.wait(); From 26c42e4ca48b24f3a86907b473384a439450b150 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 18:36:17 +0200 Subject: [PATCH 18/25] generate --- .../prototypes/evm/GatewayEVMUpgradeTest.sol | 12 -- .../prototypes/GatewayUpgradeTest.ts | 173 ++---------------- typechain-types/contracts/prototypes/index.ts | 3 + .../prototypes/interfaces.sol/IGateway.ts | 87 +-------- .../prototypes/GatewayUpgradeTest__factory.ts | 120 +----------- .../factories/contracts/prototypes/index.ts | 2 + .../interfaces.sol/IGateway__factory.ts | 41 ----- typechain-types/hardhat.d.ts | 32 ++-- typechain-types/index.ts | 4 + 9 files changed, 43 insertions(+), 431 deletions(-) diff --git a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index d555c313..db493931 100644 --- a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -37,18 +37,6 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} - /// @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); diff --git a/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts b/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts index 99a26238..d870814a 100644 --- a/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts +++ b/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts @@ -33,15 +33,12 @@ export interface GatewayUpgradeTestInterface extends utils.Interface { "custody()": FunctionFragment; "execute(address,bytes)": FunctionFragment; "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; - "initialize(address)": FunctionFragment; + "initialize()": 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; }; @@ -55,11 +52,8 @@ export interface GatewayUpgradeTestInterface extends utils.Interface { | "owner" | "proxiableUUID" | "renounceOwnership" - | "send" - | "sendERC20" | "setCustody" | "transferOwnership" - | "tssAddress" | "upgradeTo" | "upgradeToAndCall" ): FunctionFragment; @@ -80,7 +74,7 @@ export interface GatewayUpgradeTestInterface extends utils.Interface { ): string; encodeFunctionData( functionFragment: "initialize", - values: [PromiseOrValue] + values?: undefined ): string; encodeFunctionData(functionFragment: "owner", values?: undefined): string; encodeFunctionData( @@ -91,18 +85,6 @@ export interface GatewayUpgradeTestInterface 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] @@ -111,10 +93,6 @@ export interface GatewayUpgradeTestInterface extends utils.Interface { functionFragment: "transferOwnership", values: [PromiseOrValue] ): string; - encodeFunctionData( - functionFragment: "tssAddress", - values?: undefined - ): string; encodeFunctionData( functionFragment: "upgradeTo", values: [PromiseOrValue] @@ -140,14 +118,11 @@ export interface GatewayUpgradeTestInterface 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", @@ -158,22 +133,18 @@ export interface GatewayUpgradeTestInterface extends utils.Interface { "AdminChanged(address,address)": EventFragment; "BeaconUpgraded(address)": EventFragment; "ExecutedV2(address,uint256,bytes)": EventFragment; - "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "ExecutedWithERC20V2(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: "ExecutedWithERC20V2"): EventFragment; getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; - getEvent(nameOrSignatureOrTopic: "Send"): EventFragment; - getEvent(nameOrSignatureOrTopic: "SendERC20"): EventFragment; getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; } @@ -210,19 +181,19 @@ export type ExecutedV2Event = TypedEvent< export type ExecutedV2EventFilter = TypedEventFilter; -export interface ExecutedWithERC20EventObject { +export interface ExecutedWithERC20V2EventObject { token: string; to: string; amount: BigNumber; data: string; } -export type ExecutedWithERC20Event = TypedEvent< +export type ExecutedWithERC20V2Event = TypedEvent< [string, string, BigNumber, string], - ExecutedWithERC20EventObject + ExecutedWithERC20V2EventObject >; -export type ExecutedWithERC20EventFilter = - TypedEventFilter; +export type ExecutedWithERC20V2EventFilter = + TypedEventFilter; export interface InitializedEventObject { version: number; @@ -243,26 +214,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; } @@ -314,7 +265,6 @@ export interface GatewayUpgradeTest extends BaseContract { ): Promise; initialize( - _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -326,19 +276,6 @@ export interface GatewayUpgradeTest 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 } @@ -349,8 +286,6 @@ export interface GatewayUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - tssAddress(overrides?: CallOverrides): Promise<[string]>; - upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -380,7 +315,6 @@ export interface GatewayUpgradeTest extends BaseContract { ): Promise; initialize( - _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -392,19 +326,6 @@ export interface GatewayUpgradeTest 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 } @@ -415,8 +336,6 @@ export interface GatewayUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - tssAddress(overrides?: CallOverrides): Promise; - upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -445,10 +364,7 @@ export interface GatewayUpgradeTest extends BaseContract { overrides?: CallOverrides ): Promise; - initialize( - _tssAddress: PromiseOrValue, - overrides?: CallOverrides - ): Promise; + initialize(overrides?: CallOverrides): Promise; owner(overrides?: CallOverrides): Promise; @@ -456,19 +372,6 @@ export interface GatewayUpgradeTest 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 @@ -479,8 +382,6 @@ export interface GatewayUpgradeTest extends BaseContract { overrides?: CallOverrides ): Promise; - tssAddress(overrides?: CallOverrides): Promise; - upgradeTo( newImplementation: PromiseOrValue, overrides?: CallOverrides @@ -521,18 +422,18 @@ export interface GatewayUpgradeTest extends BaseContract { data?: null ): ExecutedV2EventFilter; - "ExecutedWithERC20(address,address,uint256,bytes)"( + "ExecutedWithERC20V2(address,address,uint256,bytes)"( token?: PromiseOrValue | null, to?: PromiseOrValue | null, amount?: null, data?: null - ): ExecutedWithERC20EventFilter; - ExecutedWithERC20( + ): ExecutedWithERC20V2EventFilter; + ExecutedWithERC20V2( token?: PromiseOrValue | null, to?: PromiseOrValue | null, amount?: null, data?: null - ): ExecutedWithERC20EventFilter; + ): ExecutedWithERC20V2EventFilter; "Initialized(uint8)"(version?: null): InitializedEventFilter; Initialized(version?: null): InitializedEventFilter; @@ -546,20 +447,6 @@ export interface GatewayUpgradeTest 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; @@ -586,7 +473,6 @@ export interface GatewayUpgradeTest extends BaseContract { ): Promise; initialize( - _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -598,19 +484,6 @@ export interface GatewayUpgradeTest 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 } @@ -621,8 +494,6 @@ export interface GatewayUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - tssAddress(overrides?: CallOverrides): Promise; - upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -653,7 +524,6 @@ export interface GatewayUpgradeTest extends BaseContract { ): Promise; initialize( - _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -665,19 +535,6 @@ export interface GatewayUpgradeTest 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 } @@ -688,8 +545,6 @@ export interface GatewayUpgradeTest 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/index.ts b/typechain-types/contracts/prototypes/index.ts index e5dd4614..1f0dee7e 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -3,3 +3,6 @@ /* eslint-disable */ import type * as evm from "./evm"; export type { evm }; +import type * as interfacesSol from "./interfaces.sol"; +export type { interfacesSol }; +export type { GatewayUpgradeTest } from "./GatewayUpgradeTest"; diff --git a/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts b/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts index 8eb9509d..969095cb 100644 --- a/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts +++ b/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts @@ -28,16 +28,10 @@ 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" + nameOrSignatureOrTopic: "execute" | "executeWithERC20" ): FunctionFragment; encodeFunctionData( @@ -53,26 +47,12 @@ export interface IGatewayInterface 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 IGateway 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 IGateway 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 IGateway 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 IGateway 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 IGateway 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/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts index 2a0bb549..09a34d87 100644 --- a/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts @@ -20,16 +20,6 @@ const _abi = [ name: "ExecutionFailed", type: "error", }, - { - inputs: [], - name: "InsufficientETHAmount", - type: "error", - }, - { - inputs: [], - name: "SendFailed", - type: "error", - }, { anonymous: false, inputs: [ @@ -115,7 +105,7 @@ const _abi = [ type: "bytes", }, ], - name: "ExecutedWithERC20", + name: "ExecutedWithERC20V2", type: "event", }, { @@ -150,50 +140,6 @@ 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: [ @@ -279,13 +225,7 @@ const _abi = [ type: "function", }, { - inputs: [ - { - internalType: "address", - name: "_tssAddress", - type: "address", - }, - ], + inputs: [], name: "initialize", outputs: [], stateMutability: "nonpayable", @@ -324,47 +264,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: "token", - type: "address", - }, - { - internalType: "uint256", - name: "amount", - type: "uint256", - }, - ], - name: "sendERC20", - outputs: [], - stateMutability: "nonpayable", - type: "function", - }, { inputs: [ { @@ -391,19 +290,6 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, - { - inputs: [], - name: "tssAddress", - outputs: [ - { - internalType: "address", - name: "", - type: "address", - }, - ], - stateMutability: "view", - type: "function", - }, { inputs: [ { @@ -438,7 +324,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayUpgradeTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 42f56458..510246df 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -2,3 +2,5 @@ /* tslint:disable */ /* eslint-disable */ export * as evm from "./evm"; +export * as interfacesSol from "./interfaces.sol"; +export { GatewayUpgradeTest__factory } from "./GatewayUpgradeTest__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 index 04e9ee3c..20c69449 100644 --- a/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__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 IGateway__factory { diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 185da3f5..975ec73e 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -348,14 +348,6 @@ declare module "hardhat/types/runtime" { name: "IGatewayEVM", 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 @@ -364,6 +356,14 @@ declare module "hardhat/types/runtime" { name: "TestERC20", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "GatewayUpgradeTest", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IGateway", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "ISystem", signerOrOptions?: ethers.Signer | FactoryOptions @@ -854,25 +854,25 @@ declare module "hardhat/types/runtime" { signer?: ethers.Signer ): Promise; getContractAt( - name: "GatewayUpgradeTest", + name: "Receiver", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( - name: "IGateway", + name: "TestERC20", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( - name: "Receiver", + name: "GatewayUpgradeTest", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( - name: "TestERC20", + name: "IGateway", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( name: "ISystem", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 8cf703c2..fed53e5e 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -168,6 +168,10 @@ 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 { 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 { 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 4896c5ede449320a0811a50ba21edcdb75f91434 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 18:43:03 +0200 Subject: [PATCH 19/25] cleanup comments --- contracts/prototypes/evm/GatewayEVM.sol | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 9d666122..3fc893e2 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -88,8 +88,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { return result; } - - // Deposit ETH + // Deposit ETH to tss function deposit(address receiver) external payable { if (msg.value == 0) revert InsufficientETHAmount(); (bool deposited, ) = tssAddress.call{value: msg.value}(""); @@ -101,7 +100,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { emit Deposit(msg.sender, receiver, msg.value, address(0), ""); } - // Deposit ERC20 tokens + // 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); @@ -109,7 +108,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { emit Deposit(msg.sender, receiver, amount, asset, ""); } - // Deposit ETH and call an omnichain smart contract + // 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}(""); @@ -121,7 +120,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { emit Deposit(msg.sender, receiver, msg.value, address(0), payload); } - // Deposit ERC20 tokens and call an omnichain smart contract + // 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); From 41a606fd8dbf6ddd81742a21a7464bd1260ce83e Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 18:48:12 +0200 Subject: [PATCH 20/25] missing test --- test/prototypes/GatewayIntegration.spec.ts | 32 +++++++++++++++++++ .../prototypes/evm/GatewayEVM__factory.ts | 2 +- 2 files changed, 33 insertions(+), 1 deletion(-) diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index f90dd14e..908e7ee4 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -218,6 +218,38 @@ describe("GatewayEVM inbound", function () { ); }); + 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); + await tx.wait(); + + 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"); diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index fa975c82..f9544099 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -520,7 +520,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] From cb45c9e83122dca8a675c44651d7b41a1f7769cd Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 18:49:04 +0200 Subject: [PATCH 21/25] generate --- pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go | 2 +- test/prototypes/GatewayIntegration.spec.ts | 7 ++++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index e6b2a072..aef032f2 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\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"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/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 908e7ee4..85c8cee8 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -230,7 +230,12 @@ describe("GatewayEVM inbound", function () { await token.approve(gateway.address, amount); - const tx = await gateway["depositAndCall(address,uint256,address,bytes)"](destination.address, amount, token.address, payload); + const tx = await gateway["depositAndCall(address,uint256,address,bytes)"]( + destination.address, + amount, + token.address, + payload + ); await tx.wait(); const custodyBalanceAfter = await token.balanceOf(custody.address); From 4e7e4be07c9ff242ea3f212ef5107cf2dec0125f Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 18:55:31 +0200 Subject: [PATCH 22/25] fix coderabbit comments --- contracts/prototypes/evm/GatewayEVM.sol | 5 +++++ contracts/prototypes/evm/GatewayEVMUpgradeTest.sol | 5 +++++ pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go | 4 ++-- .../evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go | 4 ++-- .../prototypes/evm/GatewayEVMUpgradeTest__factory.ts | 7 ++++++- .../contracts/prototypes/evm/GatewayEVM__factory.ts | 7 ++++++- 6 files changed, 26 insertions(+), 6 deletions(-) diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 3fc893e2..43bf4046 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -14,6 +14,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { error DepositFailed(); error InsufficientETHAmount(); error InsufficientERC20Amount(); + error ZeroAddress(); address public custody; address public tssAddress; @@ -32,6 +33,9 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { __Ownable_init(); __UUPSUpgradeable_init(); + if (_tssAddress == address(0)) { + revert ZeroAddress(); + } tssAddress = _tssAddress; } @@ -69,6 +73,7 @@ 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); // Execute the call on the target contract diff --git a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index db493931..dc58cb83 100644 --- a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -14,6 +14,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade error ExecutionFailed(); error SendFailed(); error InsufficientETHAmount(); + error ZeroAddress(); address public custody; address public tssAddress; @@ -32,6 +33,9 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade __Ownable_init(); __UUPSUpgradeable_init(); + if (_tssAddress == address(0)) { + revert ZeroAddress(); + } tssAddress = _tssAddress; } @@ -69,6 +73,7 @@ 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); // Execute the call on the target contract diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index aef032f2..937bc51f 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\"},{\"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\":\"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 2e29df28..68b06e1e 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\"},{\"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\":\"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/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts index c6014925..57a384fd 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -30,6 +30,11 @@ const _abi = [ name: "SendFailed", type: "error", }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, { anonymous: false, inputs: [ @@ -438,7 +443,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 f9544099..eb345f93 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -35,6 +35,11 @@ const _abi = [ name: "InsufficientETHAmount", type: "error", }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, { anonymous: false, inputs: [ @@ -520,7 +525,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] From c46ee9595b8e6fb50bc95e5a47282dcc1f049b3f Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 19:23:36 +0200 Subject: [PATCH 23/25] rename gateway evm spec files --- .../{GatewayIntegration.spec.ts => GatewayEVMIntegration.spec.ts} | 0 .../{GatewayUniswap.spec.ts => GatewayEVMUniswap.spec.ts} | 0 .../{GatewayUpgrade.spec.ts => GatewayEVMUpgrade.spec.ts} | 0 3 files changed, 0 insertions(+), 0 deletions(-) rename test/prototypes/{GatewayIntegration.spec.ts => GatewayEVMIntegration.spec.ts} (100%) rename test/prototypes/{GatewayUniswap.spec.ts => GatewayEVMUniswap.spec.ts} (100%) rename test/prototypes/{GatewayUpgrade.spec.ts => GatewayEVMUpgrade.spec.ts} (100%) diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayEVMIntegration.spec.ts similarity index 100% rename from test/prototypes/GatewayIntegration.spec.ts rename to test/prototypes/GatewayEVMIntegration.spec.ts diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayEVMUniswap.spec.ts similarity index 100% rename from test/prototypes/GatewayUniswap.spec.ts rename to test/prototypes/GatewayEVMUniswap.spec.ts diff --git a/test/prototypes/GatewayUpgrade.spec.ts b/test/prototypes/GatewayEVMUpgrade.spec.ts similarity index 100% rename from test/prototypes/GatewayUpgrade.spec.ts rename to test/prototypes/GatewayEVMUpgrade.spec.ts From 6ffb5cb6a3af1746d4f0ecebfb5fd540d3c75d0c Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 20:55:13 +0200 Subject: [PATCH 24/25] PR comments --- ...tewayEVMIntegration.spec.ts => GatewayEVM.spec.ts} | 11 +---------- test/prototypes/GatewayEVMUpgrade.spec.ts | 1 - 2 files changed, 1 insertion(+), 11 deletions(-) rename test/prototypes/{GatewayEVMIntegration.spec.ts => GatewayEVM.spec.ts} (98%) diff --git a/test/prototypes/GatewayEVMIntegration.spec.ts b/test/prototypes/GatewayEVM.spec.ts similarity index 98% rename from test/prototypes/GatewayEVMIntegration.spec.ts rename to test/prototypes/GatewayEVM.spec.ts index 85c8cee8..1937900b 100644 --- a/test/prototypes/GatewayEVMIntegration.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 and Receiver", function () { +describe("GatewayEVM inbound", function () { let receiver: Contract; let gateway: Contract; let token: Contract; @@ -45,7 +45,6 @@ describe("GatewayEVM and Receiver", function () { // 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); @@ -58,7 +57,6 @@ describe("GatewayEVM and Receiver", function () { 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); }); @@ -70,7 +68,6 @@ describe("GatewayEVM and Receiver", function () { // 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) @@ -95,7 +92,6 @@ describe("GatewayEVM and Receiver", function () { // 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); @@ -160,7 +156,6 @@ describe("GatewayEVM inbound", function () { await token.approve(gateway.address, amount); const tx = await gateway["deposit(address,uint256,address)"](destination.address, amount, token.address); - await tx.wait(); const custodyBalanceAfter = await token.balanceOf(custody.address); expect(custodyBalanceAfter).to.equal(amount); @@ -194,7 +189,6 @@ describe("GatewayEVM inbound", function () { const tssAddressBalanceBefore = (await ethers.provider.getBalance(tssAddress.address)) as BigNumber; const tx = await gateway["deposit(address)"](destination.address, { value: amount }); - await tx.wait(); const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); @@ -236,7 +230,6 @@ describe("GatewayEVM inbound", function () { token.address, payload ); - await tx.wait(); const custodyBalanceAfter = await token.balanceOf(custody.address); expect(custodyBalanceAfter).to.equal(amount); @@ -277,7 +270,6 @@ describe("GatewayEVM inbound", function () { const tssAddressBalanceBefore = (await ethers.provider.getBalance(tssAddress.address)) as BigNumber; const tx = await gateway["depositAndCall(address,bytes)"](destination.address, payload, { value: amount }); - await tx.wait(); const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); @@ -311,7 +303,6 @@ describe("GatewayEVM inbound", function () { const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); const tx = await gateway.call(destination.address, payload); - await tx.wait(); await expect(tx) .to.emit(gateway, "Call") diff --git a/test/prototypes/GatewayEVMUpgrade.spec.ts b/test/prototypes/GatewayEVMUpgrade.spec.ts index 8482ac52..60357e36 100644 --- a/test/prototypes/GatewayEVMUpgrade.spec.ts +++ b/test/prototypes/GatewayEVMUpgrade.spec.ts @@ -61,7 +61,6 @@ describe("GatewayEVM 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); From 4231938e99059fab26f207d69a8d0ba2b8d24bb0 Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 27 Jun 2024 01:06:16 +0200 Subject: [PATCH 25/25] remove not needed files --- contracts/prototypes/GatewayUpgradeTest.sol | 87 - contracts/prototypes/interfaces.sol | 13 - .../gatewayupgradetest.go | 1475 ----------------- .../prototypes/interfaces.sol/igateway.go | 223 --- typechain-types/contracts/prototypes/index.ts | 3 - .../factories/contracts/prototypes/index.ts | 2 - typechain-types/hardhat.d.ts | 18 - typechain-types/index.ts | 4 - 8 files changed, 1825 deletions(-) delete mode 100644 contracts/prototypes/GatewayUpgradeTest.sol delete mode 100644 contracts/prototypes/interfaces.sol delete mode 100644 pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go delete mode 100644 pkg/contracts/prototypes/interfaces.sol/igateway.go diff --git a/contracts/prototypes/GatewayUpgradeTest.sol b/contracts/prototypes/GatewayUpgradeTest.sol deleted file mode 100644 index 0a827536..00000000 --- a/contracts/prototypes/GatewayUpgradeTest.sol +++ /dev/null @@ -1,87 +0,0 @@ -// 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 deleted file mode 100644 index 58a474ae..00000000 --- a/contracts/prototypes/interfaces.sol +++ /dev/null @@ -1,13 +0,0 @@ -// 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/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/typechain-types/contracts/prototypes/index.ts b/typechain-types/contracts/prototypes/index.ts index 1f0dee7e..e5dd4614 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -3,6 +3,3 @@ /* eslint-disable */ import type * as evm from "./evm"; export type { evm }; -import type * as interfacesSol from "./interfaces.sol"; -export type { interfacesSol }; -export type { GatewayUpgradeTest } from "./GatewayUpgradeTest"; diff --git a/typechain-types/factories/contracts/prototypes/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 510246df..42f56458 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -2,5 +2,3 @@ /* tslint:disable */ /* eslint-disable */ export * as evm from "./evm"; -export * as interfacesSol from "./interfaces.sol"; -export { GatewayUpgradeTest__factory } from "./GatewayUpgradeTest__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 975ec73e..6c4d8917 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -356,14 +356,6 @@ declare module "hardhat/types/runtime" { name: "TestERC20", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "GatewayUpgradeTest", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; - getContractFactory( - name: "IGateway", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "ISystem", signerOrOptions?: ethers.Signer | FactoryOptions @@ -863,16 +855,6 @@ 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: "ISystem", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index fed53e5e..8cf703c2 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -168,10 +168,6 @@ 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 { 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 { 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";