From 04afa0f9685e58d9bef2161aa044226caed84f6e Mon Sep 17 00:00:00 2001 From: Evan Gray Date: Mon, 16 Dec 2024 15:43:14 -0500 Subject: [PATCH] tilt: e2e with mm and executor --- Tiltfile | 59 +- evm/lib/example-messaging-executor | 2 +- evm/src/NttManager/NttManager.sol | 20 +- evm/ts/package.json | 2 +- evm/ts/src/bindings.ts | 10 +- .../src/ethers-contracts/2_0_0/NttManager.ts | 1849 ++++++++++++++ evm/ts/src/ethers-contracts/2_0_0/common.ts | 131 + .../2_0_0/factories/NttManager__factory.ts | 2147 +++++++++++++++++ .../ethers-contracts/2_0_0/factories/index.ts | 4 + evm/ts/src/ethers-contracts/2_0_0/index.ts | 6 + evm/ts/src/ethers-contracts/index.ts | 9 +- evm/ts/src/executor/BinaryReader.ts | 106 + evm/ts/src/executor/BinaryWriter.ts | 91 + evm/ts/src/executor/fetch.ts | 23 + evm/ts/src/executor/relayInstructions.ts | 92 + evm/ts/src/ntt.ts | 128 +- package-lock.json | 7 +- package.json | 1 + sdk/Dockerfile | 3 +- sdk/__tests__/index.test.ts | 16 +- sdk/__tests__/utils.ts | 352 +-- sdk/definitions/src/ntt.ts | 4 +- solana/tests/anchor.test.ts | 2 +- solana/ts/sdk/ntt.ts | 2 + tilt/Dockerfile.deploy | 40 + tilt/Dockerfile.executor | 13 + tilt/deploy.sh | 29 + tilt/executor-deploy.yaml | 24 + tilt/executor.yaml | 48 + 29 files changed, 4950 insertions(+), 270 deletions(-) create mode 100644 evm/ts/src/ethers-contracts/2_0_0/NttManager.ts create mode 100644 evm/ts/src/ethers-contracts/2_0_0/common.ts create mode 100644 evm/ts/src/ethers-contracts/2_0_0/factories/NttManager__factory.ts create mode 100644 evm/ts/src/ethers-contracts/2_0_0/factories/index.ts create mode 100644 evm/ts/src/ethers-contracts/2_0_0/index.ts create mode 100644 evm/ts/src/executor/BinaryReader.ts create mode 100644 evm/ts/src/executor/BinaryWriter.ts create mode 100644 evm/ts/src/executor/fetch.ts create mode 100644 evm/ts/src/executor/relayInstructions.ts create mode 100644 tilt/Dockerfile.deploy create mode 100644 tilt/Dockerfile.executor create mode 100644 tilt/deploy.sh create mode 100644 tilt/executor-deploy.yaml create mode 100644 tilt/executor.yaml diff --git a/Tiltfile b/Tiltfile index 0655dcba9..526d86b3e 100644 --- a/Tiltfile +++ b/Tiltfile @@ -14,20 +14,20 @@ docker_build( ignore=["./sdk/__tests__", "./sdk/Dockerfile", "./sdk/ci.yaml", "./sdk/**/dist", "./sdk/node_modules", "./sdk/**/node_modules"], dockerfile = "./solana/Dockerfile", ) -docker_build( - ref = "solana-test-validator", - context = "solana", - dockerfile = "solana/Dockerfile.test-validator" -) -k8s_yaml_with_ns("./solana/solana-devnet.yaml") -k8s_resource( - "solana-devnet", - labels = ["anchor-ntt"], - port_forwards = [ - port_forward(8899, name = "Solana RPC [:8899]"), - port_forward(8900, name = "Solana WS [:8900]"), - ], -) +# docker_build( +# ref = "solana-test-validator", +# context = "solana", +# dockerfile = "solana/Dockerfile.test-validator" +# ) +# k8s_yaml_with_ns("./solana/solana-devnet.yaml") +# k8s_resource( +# "solana-devnet", +# labels = ["anchor-ntt"], +# port_forwards = [ +# port_forward(8899, name = "Solana RPC [:8899]"), +# port_forward(8900, name = "Solana WS [:8900]"), +# ], +# ) # EVM build docker_build( @@ -36,6 +36,35 @@ docker_build( dockerfile = "./evm/Dockerfile", ) +# MM and Executor Contract Deploy / Setup +docker_build( + ref = "executor-deploy", + context = "tilt", + dockerfile = "tilt/Dockerfile.deploy", + only = ["deploy.sh"] +) +docker_build( + ref = "executor", + context = "tilt", + dockerfile = "tilt/Dockerfile.executor", + only = [], +) +k8s_yaml_with_ns("tilt/executor-deploy.yaml") +k8s_resource( + "executor-deploy", + labels = ["executor"], + resource_deps = ["eth-devnet", "eth-devnet2"], +) +k8s_yaml_with_ns("tilt/executor.yaml") +k8s_resource( + "executor", + labels = ["executor"], + resource_deps = ["eth-devnet", "eth-devnet2", "guardian", "executor-deploy"], + port_forwards = [ + port_forward(3000, name = "Executor [:3000]"), + ], +) + # CI tests docker_build( ref = "ntt-ci", @@ -47,5 +76,5 @@ k8s_yaml_with_ns("./sdk/ci.yaml") k8s_resource( "ntt-ci-tests", labels = ["ntt"], - resource_deps = ["eth-devnet", "eth-devnet2", "solana-devnet", "guardian", "relayer-engine", "wormchain"], + resource_deps = ["eth-devnet", "eth-devnet2", "solana-devnet", "guardian", "relayer-engine", "wormchain", "executor"], ) diff --git a/evm/lib/example-messaging-executor b/evm/lib/example-messaging-executor index d6125d67a..57c49d9ad 160000 --- a/evm/lib/example-messaging-executor +++ b/evm/lib/example-messaging-executor @@ -1 +1 @@ -Subproject commit d6125d67ac3f68c65045e954941cf3fd2d78387a +Subproject commit 57c49d9ad7c410b9a7f938e07a5444f07872159d diff --git a/evm/src/NttManager/NttManager.sol b/evm/src/NttManager/NttManager.sol index 17ee9bb17..78f9f3fb8 100644 --- a/evm/src/NttManager/NttManager.sol +++ b/evm/src/NttManager/NttManager.sol @@ -42,7 +42,7 @@ contract NttManager is INttManager, RateLimiter, ManagerBase { using TrimmedAmountLib for uint256; using TrimmedAmountLib for TrimmedAmount; - string public constant NTT_MANAGER_VERSION = "1.1.0"; + string public constant NTT_MANAGER_VERSION = "2.0.0"; // =============== Setup ================================================================= @@ -597,7 +597,8 @@ contract NttManager is INttManager, RateLimiter, ManagerBase { checkFork(evmChainId); // Compute the quote price and refund user excess value from msg.value - uint256 epTotalPriceQuote = quoteAndRefund(recipientChain, transceiverInstructions); + (uint256 epTotalPriceQuote, uint256 excessValue) = + quoteEndpoint(recipientChain, transceiverInstructions); return _transfer( _TransferArgs({ @@ -610,7 +611,8 @@ contract NttManager is INttManager, RateLimiter, ManagerBase { executorQuote: executorQuote, relayInstructions: relayInstructions, transceiverInstructions: transceiverInstructions, - epTotalPriceQuote: epTotalPriceQuote + epTotalPriceQuote: epTotalPriceQuote, + excessValue: excessValue }) ); } @@ -627,6 +629,7 @@ contract NttManager is INttManager, RateLimiter, ManagerBase { bytes relayInstructions; bytes transceiverInstructions; uint256 epTotalPriceQuote; + uint256 excessValue; } function _transfer( @@ -667,7 +670,7 @@ contract NttManager is INttManager, RateLimiter, ManagerBase { relayInstructions = abi.encodePacked(relayInstructions, args.relayInstructions); } - executor.requestExecution( + executor.requestExecution{value: args.excessValue}( args.recipientChain, peerData.peerAddress, UniversalAddressLibrary.fromBytes32(args.refundAddress).toAddress(), @@ -682,15 +685,12 @@ contract NttManager is INttManager, RateLimiter, ManagerBase { return args.sequence; } - function quoteAndRefund( + function quoteEndpoint( uint16 recipientChain, bytes memory transceiverInstructions - ) internal returns (uint256 epTotalPriceQuote) { + ) internal returns (uint256 epTotalPriceQuote, uint256 excessValue) { epTotalPriceQuote = quoteDeliveryPrice(recipientChain, transceiverInstructions); - uint256 excessValue = msg.value - epTotalPriceQuote; - if (excessValue > 0) { - _refundToSender(excessValue); - } + excessValue = msg.value - epTotalPriceQuote; } function buildEncodedPayload( diff --git a/evm/ts/package.json b/evm/ts/package.json index 07a0e6a1f..43fc8a36c 100644 --- a/evm/ts/package.json +++ b/evm/ts/package.json @@ -37,7 +37,7 @@ "build": "npm run build:esm && npm run build:cjs", "rebuild": "npm run clean && npm run build", "clean": "rm -rf ./dist", - "generate:test": "typechain --node16-modules --target ethers-v6 --out-dir ethers-ci-contracts '../out/**/*.json'", + "generate:test": "typechain --node16-modules --target ethers-v6 --out-dir ethers-ci-contracts '../out/?(WormholeTransceiver.sol|NttManager.sol)/*.json'", "generate:slim": "ABI_VERSION=`tsx scripts/readVersion.ts` && typechain --node16-modules --target ethers-v6 --out-dir src/ethers-contracts/$ABI_VERSION '../out/?(WormholeTransceiver.sol|NttManager.sol)/*.json'", "generate": "npm run generate:slim", "build:contracts": "cd ../.. && make build-evm-prod", diff --git a/evm/ts/src/bindings.ts b/evm/ts/src/bindings.ts index 40beff958..6083be15e 100644 --- a/evm/ts/src/bindings.ts +++ b/evm/ts/src/bindings.ts @@ -1,16 +1,12 @@ import { Provider } from "ethers"; -import { _0_1_0, _1_0_0, _1_1_0 } from "./ethers-contracts/index.js"; +import { _0_1_0, _1_0_0, _1_1_0, _2_0_0 } from "./ethers-contracts/index.js"; import { Ntt } from "@wormhole-foundation/sdk-definitions-ntt"; // This is a descending list of all ABI versions the SDK is aware of. // We check for the first match in descending order, allowing for higher minor and patch versions // being used by the live contract (these are supposed to still be compatible with older ABIs). -export const abiVersions = [ - ["1.1.0", _1_1_0], - ["1.0.0", _1_0_0], - ["0.1.0", _0_1_0], -] as const; +export const abiVersions = [["2.0.0", _2_0_0]] as const; export type AbiVersion = (typeof abiVersions)[number][0]; export interface NttBindings { @@ -32,7 +28,7 @@ export interface NttTransceiverBindings { } export namespace NttManagerBindings { - export type NttManager = ReturnType; + export type NttManager = ReturnType; } export interface NttManagerBindings { diff --git a/evm/ts/src/ethers-contracts/2_0_0/NttManager.ts b/evm/ts/src/ethers-contracts/2_0_0/NttManager.ts new file mode 100644 index 000000000..545673451 --- /dev/null +++ b/evm/ts/src/ethers-contracts/2_0_0/NttManager.ts @@ -0,0 +1,1849 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumberish, + BytesLike, + FunctionFragment, + Result, + Interface, + EventFragment, + AddressLike, + ContractRunner, + ContractMethod, + Listener, +} from "ethers"; +import type { + TypedContractEvent, + TypedDeferredTopicFilter, + TypedEventLog, + TypedLogDescription, + TypedListener, + TypedContractMethod, +} from "./common.js"; + +export declare namespace IRateLimiter { + export type RateLimitParamsStruct = { + limit: BigNumberish; + currentCapacity: BigNumberish; + lastTxTimestamp: BigNumberish; + }; + + export type RateLimitParamsStructOutput = [ + limit: bigint, + currentCapacity: bigint, + lastTxTimestamp: bigint + ] & { limit: bigint; currentCapacity: bigint; lastTxTimestamp: bigint }; + + export type InboundQueuedTransferStruct = { + amount: BigNumberish; + txTimestamp: BigNumberish; + recipient: AddressLike; + }; + + export type InboundQueuedTransferStructOutput = [ + amount: bigint, + txTimestamp: bigint, + recipient: string + ] & { amount: bigint; txTimestamp: bigint; recipient: string }; + + export type OutboundQueuedTransferStruct = { + recipient: BytesLike; + refundAddress: BytesLike; + amount: BigNumberish; + txTimestamp: BigNumberish; + recipientChain: BigNumberish; + sender: AddressLike; + executorQuote: BytesLike; + relayInstructions: BytesLike; + transceiverInstructions: BytesLike; + }; + + export type OutboundQueuedTransferStructOutput = [ + recipient: string, + refundAddress: string, + amount: bigint, + txTimestamp: bigint, + recipientChain: bigint, + sender: string, + executorQuote: string, + relayInstructions: string, + transceiverInstructions: string + ] & { + recipient: string; + refundAddress: string; + amount: bigint; + txTimestamp: bigint; + recipientChain: bigint; + sender: string; + executorQuote: string; + relayInstructions: string; + transceiverInstructions: string; + }; +} + +export declare namespace INttManager { + export type NttManagerPeerStruct = { + peerAddress: BytesLike; + tokenDecimals: BigNumberish; + gasLimit: BigNumberish; + }; + + export type NttManagerPeerStructOutput = [ + peerAddress: string, + tokenDecimals: bigint, + gasLimit: bigint + ] & { peerAddress: string; tokenDecimals: bigint; gasLimit: bigint }; +} + +export interface NttManagerInterface extends Interface { + getFunction( + nameOrSignature: + | "NTT_MANAGER_VERSION" + | "cancelOutboundQueuedTransfer" + | "chainId" + | "completeInboundQueuedTransfer" + | "completeOutboundQueuedTransfer" + | "disableRecvTransceiver" + | "disableSendTransceiver" + | "enableRecvTransceiver" + | "enableSendTransceiver" + | "endpoint" + | "executeMsg" + | "executor" + | "getCurrentInboundCapacity" + | "getCurrentOutboundCapacity" + | "getInboundLimitParams" + | "getInboundQueuedTransfer" + | "getMigratesImmutables" + | "getMode" + | "getOutboundLimitParams" + | "getOutboundQueuedTransfer" + | "getPeer" + | "getThreshold" + | "initialize" + | "isMessageApproved" + | "isMessageExecuted" + | "isPaused" + | "messageAttestations" + | "migrate" + | "mode" + | "nextMessageSequence" + | "owner" + | "pause" + | "pauser" + | "quoteDeliveryPrice" + | "rateLimitDuration" + | "setGasLimit" + | "setInboundLimit" + | "setOutboundLimit" + | "setPeer" + | "setThreshold" + | "setTransceiver" + | "token" + | "tokenDecimals" + | "transceiverAttestedToMessage" + | "transfer(uint256,uint16,bytes32,bytes32,bool,bytes,bytes,bytes)" + | "transfer(uint256,uint16,bytes32,bytes,bytes,bytes)" + | "transferOwnership" + | "transferPauserCapability" + | "unpause" + | "upgrade" + ): FunctionFragment; + + getEvent( + nameOrSignatureOrTopic: + | "AdminChanged" + | "BeaconUpgraded" + | "InboundTransferLimitUpdated" + | "InboundTransferQueued" + | "Initialized" + | "MessageAttestedTo" + | "NotPaused" + | "OutboundTransferCancelled" + | "OutboundTransferLimitUpdated" + | "OutboundTransferQueued" + | "OutboundTransferRateLimited" + | "OwnershipTransferred" + | "Paused" + | "PauserTransferred" + | "PeerUpdated" + | "ThresholdChanged" + | "TransceiverAdded" + | "TransferRedeemed" + | "TransferSent(bytes32,bytes32,uint256,uint256,uint16,uint64,bytes32)" + | "TransferSent(bytes32)" + | "Upgraded" + ): EventFragment; + + encodeFunctionData( + functionFragment: "NTT_MANAGER_VERSION", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "cancelOutboundQueuedTransfer", + values: [BigNumberish] + ): string; + encodeFunctionData(functionFragment: "chainId", values?: undefined): string; + encodeFunctionData( + functionFragment: "completeInboundQueuedTransfer", + values: [BytesLike] + ): string; + encodeFunctionData( + functionFragment: "completeOutboundQueuedTransfer", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "disableRecvTransceiver", + values: [BigNumberish, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "disableSendTransceiver", + values: [BigNumberish, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "enableRecvTransceiver", + values: [BigNumberish, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "enableSendTransceiver", + values: [BigNumberish, AddressLike] + ): string; + encodeFunctionData(functionFragment: "endpoint", values?: undefined): string; + encodeFunctionData( + functionFragment: "executeMsg", + values: [BigNumberish, BytesLike, BigNumberish, BytesLike] + ): string; + encodeFunctionData(functionFragment: "executor", values?: undefined): string; + encodeFunctionData( + functionFragment: "getCurrentInboundCapacity", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getCurrentOutboundCapacity", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getInboundLimitParams", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getInboundQueuedTransfer", + values: [BytesLike] + ): string; + encodeFunctionData( + functionFragment: "getMigratesImmutables", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "getMode", values?: undefined): string; + encodeFunctionData( + functionFragment: "getOutboundLimitParams", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getOutboundQueuedTransfer", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getPeer", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getThreshold", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "isMessageApproved", + values: [BigNumberish, BytesLike, BigNumberish, BytesLike, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "isMessageExecuted", + values: [BigNumberish, BytesLike, BigNumberish, BytesLike, BytesLike] + ): string; + encodeFunctionData(functionFragment: "isPaused", values?: undefined): string; + encodeFunctionData( + functionFragment: "messageAttestations", + values: [BigNumberish, BytesLike, BigNumberish, BytesLike, BytesLike] + ): string; + encodeFunctionData(functionFragment: "migrate", values?: undefined): string; + encodeFunctionData(functionFragment: "mode", values?: undefined): string; + encodeFunctionData( + functionFragment: "nextMessageSequence", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData(functionFragment: "pause", values?: undefined): string; + encodeFunctionData(functionFragment: "pauser", values?: undefined): string; + encodeFunctionData( + functionFragment: "quoteDeliveryPrice", + values: [BigNumberish, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "rateLimitDuration", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "setGasLimit", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setInboundLimit", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setOutboundLimit", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setPeer", + values: [BigNumberish, BytesLike, BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setThreshold", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setTransceiver", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "token", values?: undefined): string; + encodeFunctionData( + functionFragment: "tokenDecimals", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transceiverAttestedToMessage", + values: [ + BigNumberish, + BytesLike, + BigNumberish, + BytesLike, + BytesLike, + BigNumberish + ] + ): string; + encodeFunctionData( + functionFragment: "transfer(uint256,uint16,bytes32,bytes32,bool,bytes,bytes,bytes)", + values: [ + BigNumberish, + BigNumberish, + BytesLike, + BytesLike, + boolean, + BytesLike, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "transfer(uint256,uint16,bytes32,bytes,bytes,bytes)", + values: [ + BigNumberish, + BigNumberish, + BytesLike, + BytesLike, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "transferPauserCapability", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "unpause", values?: undefined): string; + encodeFunctionData( + functionFragment: "upgrade", + values: [AddressLike] + ): string; + + decodeFunctionResult( + functionFragment: "NTT_MANAGER_VERSION", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "cancelOutboundQueuedTransfer", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "chainId", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "completeInboundQueuedTransfer", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "completeOutboundQueuedTransfer", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "disableRecvTransceiver", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "disableSendTransceiver", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "enableRecvTransceiver", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "enableSendTransceiver", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "endpoint", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "executeMsg", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "executor", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getCurrentInboundCapacity", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getCurrentOutboundCapacity", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getInboundLimitParams", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getInboundQueuedTransfer", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getMigratesImmutables", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getMode", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getOutboundLimitParams", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getOutboundQueuedTransfer", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getPeer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getThreshold", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "isMessageApproved", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isMessageExecuted", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "isPaused", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "messageAttestations", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "migrate", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "mode", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "nextMessageSequence", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "pauser", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "quoteDeliveryPrice", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "rateLimitDuration", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setGasLimit", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setInboundLimit", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setOutboundLimit", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setPeer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "setThreshold", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setTransceiver", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "token", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "tokenDecimals", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transceiverAttestedToMessage", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transfer(uint256,uint16,bytes32,bytes32,bool,bytes,bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transfer(uint256,uint16,bytes32,bytes,bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferPauserCapability", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "upgrade", data: BytesLike): Result; +} + +export namespace AdminChangedEvent { + export type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike]; + export type OutputTuple = [previousAdmin: string, newAdmin: string]; + export interface OutputObject { + previousAdmin: string; + newAdmin: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace BeaconUpgradedEvent { + export type InputTuple = [beacon: AddressLike]; + export type OutputTuple = [beacon: string]; + export interface OutputObject { + beacon: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace InboundTransferLimitUpdatedEvent { + export type InputTuple = [ + chainId: BigNumberish, + oldLimit: BigNumberish, + newLimit: BigNumberish + ]; + export type OutputTuple = [ + chainId: bigint, + oldLimit: bigint, + newLimit: bigint + ]; + export interface OutputObject { + chainId: bigint; + oldLimit: bigint; + newLimit: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace InboundTransferQueuedEvent { + export type InputTuple = [digest: BytesLike]; + export type OutputTuple = [digest: string]; + export interface OutputObject { + digest: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace InitializedEvent { + export type InputTuple = [version: BigNumberish]; + export type OutputTuple = [version: bigint]; + export interface OutputObject { + version: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace MessageAttestedToEvent { + export type InputTuple = [ + digest: BytesLike, + transceiver: AddressLike, + index: BigNumberish + ]; + export type OutputTuple = [ + digest: string, + transceiver: string, + index: bigint + ]; + export interface OutputObject { + digest: string; + transceiver: string; + index: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace NotPausedEvent { + export type InputTuple = [notPaused: boolean]; + export type OutputTuple = [notPaused: boolean]; + export interface OutputObject { + notPaused: boolean; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace OutboundTransferCancelledEvent { + export type InputTuple = [ + sequence: BigNumberish, + recipient: AddressLike, + amount: BigNumberish + ]; + export type OutputTuple = [ + sequence: bigint, + recipient: string, + amount: bigint + ]; + export interface OutputObject { + sequence: bigint; + recipient: string; + amount: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace OutboundTransferLimitUpdatedEvent { + export type InputTuple = [oldLimit: BigNumberish, newLimit: BigNumberish]; + export type OutputTuple = [oldLimit: bigint, newLimit: bigint]; + export interface OutputObject { + oldLimit: bigint; + newLimit: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace OutboundTransferQueuedEvent { + export type InputTuple = [queueSequence: BigNumberish]; + export type OutputTuple = [queueSequence: bigint]; + export interface OutputObject { + queueSequence: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace OutboundTransferRateLimitedEvent { + export type InputTuple = [ + sender: AddressLike, + sequence: BigNumberish, + amount: BigNumberish, + currentCapacity: BigNumberish + ]; + export type OutputTuple = [ + sender: string, + sequence: bigint, + amount: bigint, + currentCapacity: bigint + ]; + export interface OutputObject { + sender: string; + sequence: bigint; + amount: bigint; + currentCapacity: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace OwnershipTransferredEvent { + export type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike]; + export type OutputTuple = [previousOwner: string, newOwner: string]; + export interface OutputObject { + previousOwner: string; + newOwner: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace PausedEvent { + export type InputTuple = [paused: boolean]; + export type OutputTuple = [paused: boolean]; + export interface OutputObject { + paused: boolean; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace PauserTransferredEvent { + export type InputTuple = [oldPauser: AddressLike, newPauser: AddressLike]; + export type OutputTuple = [oldPauser: string, newPauser: string]; + export interface OutputObject { + oldPauser: string; + newPauser: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace PeerUpdatedEvent { + export type InputTuple = [ + chainId_: BigNumberish, + oldPeerContract: BytesLike, + oldPeerDecimals: BigNumberish, + peerContract: BytesLike, + peerDecimals: BigNumberish + ]; + export type OutputTuple = [ + chainId_: bigint, + oldPeerContract: string, + oldPeerDecimals: bigint, + peerContract: string, + peerDecimals: bigint + ]; + export interface OutputObject { + chainId_: bigint; + oldPeerContract: string; + oldPeerDecimals: bigint; + peerContract: string; + peerDecimals: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace ThresholdChangedEvent { + export type InputTuple = [ + chainId: BigNumberish, + oldThreshold: BigNumberish, + threshold: BigNumberish + ]; + export type OutputTuple = [ + chainId: bigint, + oldThreshold: bigint, + threshold: bigint + ]; + export interface OutputObject { + chainId: bigint; + oldThreshold: bigint; + threshold: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace TransceiverAddedEvent { + export type InputTuple = [ + transceiver: AddressLike, + transceiversNum: BigNumberish + ]; + export type OutputTuple = [transceiver: string, transceiversNum: bigint]; + export interface OutputObject { + transceiver: string; + transceiversNum: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace TransferRedeemedEvent { + export type InputTuple = [digest: BytesLike]; + export type OutputTuple = [digest: string]; + export interface OutputObject { + digest: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace TransferSent_bytes32_bytes32_uint256_uint256_uint16_uint64_bytes32_Event { + export type InputTuple = [ + recipient: BytesLike, + refundAddress: BytesLike, + amount: BigNumberish, + fee: BigNumberish, + recipientChain: BigNumberish, + msgSequence: BigNumberish, + msgHash: BytesLike + ]; + export type OutputTuple = [ + recipient: string, + refundAddress: string, + amount: bigint, + fee: bigint, + recipientChain: bigint, + msgSequence: bigint, + msgHash: string + ]; + export interface OutputObject { + recipient: string; + refundAddress: string; + amount: bigint; + fee: bigint; + recipientChain: bigint; + msgSequence: bigint; + msgHash: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace TransferSent_bytes32_Event { + export type InputTuple = [digest: BytesLike]; + export type OutputTuple = [digest: string]; + export interface OutputObject { + digest: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace UpgradedEvent { + export type InputTuple = [implementation: AddressLike]; + export type OutputTuple = [implementation: string]; + export interface OutputObject { + implementation: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export interface NttManager extends BaseContract { + connect(runner?: ContractRunner | null): NttManager; + waitForDeployment(): Promise; + + interface: NttManagerInterface; + + queryFilter( + event: TCEvent, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>>; + queryFilter( + filter: TypedDeferredTopicFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>>; + + on( + event: TCEvent, + listener: TypedListener + ): Promise; + on( + filter: TypedDeferredTopicFilter, + listener: TypedListener + ): Promise; + + once( + event: TCEvent, + listener: TypedListener + ): Promise; + once( + filter: TypedDeferredTopicFilter, + listener: TypedListener + ): Promise; + + listeners( + event: TCEvent + ): Promise>>; + listeners(eventName?: string): Promise>; + removeAllListeners( + event?: TCEvent + ): Promise; + + NTT_MANAGER_VERSION: TypedContractMethod<[], [string], "view">; + + cancelOutboundQueuedTransfer: TypedContractMethod< + [messageSequence: BigNumberish], + [void], + "nonpayable" + >; + + chainId: TypedContractMethod<[], [bigint], "view">; + + completeInboundQueuedTransfer: TypedContractMethod< + [digest: BytesLike], + [void], + "nonpayable" + >; + + completeOutboundQueuedTransfer: TypedContractMethod< + [messageSequence: BigNumberish], + [bigint], + "payable" + >; + + disableRecvTransceiver: TypedContractMethod< + [chain: BigNumberish, transceiver: AddressLike], + [void], + "nonpayable" + >; + + disableSendTransceiver: TypedContractMethod< + [chain: BigNumberish, transceiver: AddressLike], + [void], + "nonpayable" + >; + + enableRecvTransceiver: TypedContractMethod< + [chain: BigNumberish, transceiver: AddressLike], + [void], + "nonpayable" + >; + + enableSendTransceiver: TypedContractMethod< + [chain: BigNumberish, transceiver: AddressLike], + [void], + "nonpayable" + >; + + endpoint: TypedContractMethod<[], [string], "view">; + + executeMsg: TypedContractMethod< + [ + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + epSeq: BigNumberish, + payload: BytesLike + ], + [void], + "nonpayable" + >; + + executor: TypedContractMethod<[], [string], "view">; + + getCurrentInboundCapacity: TypedContractMethod< + [chainId_: BigNumberish], + [bigint], + "view" + >; + + getCurrentOutboundCapacity: TypedContractMethod<[], [bigint], "view">; + + getInboundLimitParams: TypedContractMethod< + [chainId_: BigNumberish], + [IRateLimiter.RateLimitParamsStructOutput], + "view" + >; + + getInboundQueuedTransfer: TypedContractMethod< + [digest: BytesLike], + [IRateLimiter.InboundQueuedTransferStructOutput], + "view" + >; + + getMigratesImmutables: TypedContractMethod<[], [boolean], "view">; + + getMode: TypedContractMethod<[], [bigint], "view">; + + getOutboundLimitParams: TypedContractMethod< + [], + [IRateLimiter.RateLimitParamsStructOutput], + "view" + >; + + getOutboundQueuedTransfer: TypedContractMethod< + [queueSequence: BigNumberish], + [IRateLimiter.OutboundQueuedTransferStructOutput], + "view" + >; + + getPeer: TypedContractMethod< + [chainId_: BigNumberish], + [INttManager.NttManagerPeerStructOutput], + "view" + >; + + getThreshold: TypedContractMethod<[chain: BigNumberish], [bigint], "view">; + + initialize: TypedContractMethod<[], [void], "payable">; + + isMessageApproved: TypedContractMethod< + [ + srcChain: BigNumberish, + srcAddr: BytesLike, + sequence: BigNumberish, + dstAddr: BytesLike, + payloadHash: BytesLike + ], + [boolean], + "view" + >; + + isMessageExecuted: TypedContractMethod< + [ + srcChain: BigNumberish, + srcAddr: BytesLike, + sequence: BigNumberish, + dstAddr: BytesLike, + payloadHash: BytesLike + ], + [boolean], + "view" + >; + + isPaused: TypedContractMethod<[], [boolean], "view">; + + messageAttestations: TypedContractMethod< + [ + srcChain: BigNumberish, + srcAddr: BytesLike, + sequence: BigNumberish, + dstAddr: BytesLike, + payloadHash: BytesLike + ], + [bigint], + "view" + >; + + migrate: TypedContractMethod<[], [void], "nonpayable">; + + mode: TypedContractMethod<[], [bigint], "view">; + + nextMessageSequence: TypedContractMethod<[], [bigint], "view">; + + owner: TypedContractMethod<[], [string], "view">; + + pause: TypedContractMethod<[], [void], "nonpayable">; + + pauser: TypedContractMethod<[], [string], "view">; + + quoteDeliveryPrice: TypedContractMethod< + [recipientChain: BigNumberish, transceiverInstructions: BytesLike], + [bigint], + "view" + >; + + rateLimitDuration: TypedContractMethod<[], [bigint], "view">; + + setGasLimit: TypedContractMethod< + [peerChainId: BigNumberish, gasLimit: BigNumberish], + [void], + "nonpayable" + >; + + setInboundLimit: TypedContractMethod< + [limit: BigNumberish, chainId_: BigNumberish], + [void], + "nonpayable" + >; + + setOutboundLimit: TypedContractMethod< + [limit: BigNumberish], + [void], + "nonpayable" + >; + + setPeer: TypedContractMethod< + [ + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + gasLimit: BigNumberish, + inboundLimit: BigNumberish + ], + [void], + "nonpayable" + >; + + setThreshold: TypedContractMethod< + [chain: BigNumberish, threshold: BigNumberish], + [void], + "nonpayable" + >; + + setTransceiver: TypedContractMethod< + [transceiver: AddressLike], + [void], + "nonpayable" + >; + + token: TypedContractMethod<[], [string], "view">; + + tokenDecimals: TypedContractMethod<[], [bigint], "view">; + + transceiverAttestedToMessage: TypedContractMethod< + [ + srcChain: BigNumberish, + srcAddr: BytesLike, + sequence: BigNumberish, + dstAddr: BytesLike, + payloadHash: BytesLike, + index: BigNumberish + ], + [boolean], + "view" + >; + + "transfer(uint256,uint16,bytes32,bytes32,bool,bytes,bytes,bytes)": TypedContractMethod< + [ + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + refundAddress: BytesLike, + shouldQueue: boolean, + executorQuote: BytesLike, + relayInstructions: BytesLike, + transceiverInstructions: BytesLike + ], + [bigint], + "payable" + >; + + "transfer(uint256,uint16,bytes32,bytes,bytes,bytes)": TypedContractMethod< + [ + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + executorQuote: BytesLike, + relayInstructions: BytesLike, + transceiverInstructions: BytesLike + ], + [bigint], + "payable" + >; + + transferOwnership: TypedContractMethod< + [newOwner: AddressLike], + [void], + "nonpayable" + >; + + transferPauserCapability: TypedContractMethod< + [newPauser: AddressLike], + [void], + "nonpayable" + >; + + unpause: TypedContractMethod<[], [void], "nonpayable">; + + upgrade: TypedContractMethod< + [newImplementation: AddressLike], + [void], + "nonpayable" + >; + + getFunction( + key: string | FunctionFragment + ): T; + + getFunction( + nameOrSignature: "NTT_MANAGER_VERSION" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "cancelOutboundQueuedTransfer" + ): TypedContractMethod<[messageSequence: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "chainId" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "completeInboundQueuedTransfer" + ): TypedContractMethod<[digest: BytesLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "completeOutboundQueuedTransfer" + ): TypedContractMethod<[messageSequence: BigNumberish], [bigint], "payable">; + getFunction( + nameOrSignature: "disableRecvTransceiver" + ): TypedContractMethod< + [chain: BigNumberish, transceiver: AddressLike], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "disableSendTransceiver" + ): TypedContractMethod< + [chain: BigNumberish, transceiver: AddressLike], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "enableRecvTransceiver" + ): TypedContractMethod< + [chain: BigNumberish, transceiver: AddressLike], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "enableSendTransceiver" + ): TypedContractMethod< + [chain: BigNumberish, transceiver: AddressLike], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "endpoint" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "executeMsg" + ): TypedContractMethod< + [ + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + epSeq: BigNumberish, + payload: BytesLike + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "executor" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "getCurrentInboundCapacity" + ): TypedContractMethod<[chainId_: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "getCurrentOutboundCapacity" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "getInboundLimitParams" + ): TypedContractMethod< + [chainId_: BigNumberish], + [IRateLimiter.RateLimitParamsStructOutput], + "view" + >; + getFunction( + nameOrSignature: "getInboundQueuedTransfer" + ): TypedContractMethod< + [digest: BytesLike], + [IRateLimiter.InboundQueuedTransferStructOutput], + "view" + >; + getFunction( + nameOrSignature: "getMigratesImmutables" + ): TypedContractMethod<[], [boolean], "view">; + getFunction( + nameOrSignature: "getMode" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "getOutboundLimitParams" + ): TypedContractMethod< + [], + [IRateLimiter.RateLimitParamsStructOutput], + "view" + >; + getFunction( + nameOrSignature: "getOutboundQueuedTransfer" + ): TypedContractMethod< + [queueSequence: BigNumberish], + [IRateLimiter.OutboundQueuedTransferStructOutput], + "view" + >; + getFunction( + nameOrSignature: "getPeer" + ): TypedContractMethod< + [chainId_: BigNumberish], + [INttManager.NttManagerPeerStructOutput], + "view" + >; + getFunction( + nameOrSignature: "getThreshold" + ): TypedContractMethod<[chain: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "initialize" + ): TypedContractMethod<[], [void], "payable">; + getFunction( + nameOrSignature: "isMessageApproved" + ): TypedContractMethod< + [ + srcChain: BigNumberish, + srcAddr: BytesLike, + sequence: BigNumberish, + dstAddr: BytesLike, + payloadHash: BytesLike + ], + [boolean], + "view" + >; + getFunction( + nameOrSignature: "isMessageExecuted" + ): TypedContractMethod< + [ + srcChain: BigNumberish, + srcAddr: BytesLike, + sequence: BigNumberish, + dstAddr: BytesLike, + payloadHash: BytesLike + ], + [boolean], + "view" + >; + getFunction( + nameOrSignature: "isPaused" + ): TypedContractMethod<[], [boolean], "view">; + getFunction( + nameOrSignature: "messageAttestations" + ): TypedContractMethod< + [ + srcChain: BigNumberish, + srcAddr: BytesLike, + sequence: BigNumberish, + dstAddr: BytesLike, + payloadHash: BytesLike + ], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "migrate" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "mode" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "nextMessageSequence" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "owner" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "pause" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "pauser" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "quoteDeliveryPrice" + ): TypedContractMethod< + [recipientChain: BigNumberish, transceiverInstructions: BytesLike], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "rateLimitDuration" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "setGasLimit" + ): TypedContractMethod< + [peerChainId: BigNumberish, gasLimit: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "setInboundLimit" + ): TypedContractMethod< + [limit: BigNumberish, chainId_: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "setOutboundLimit" + ): TypedContractMethod<[limit: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "setPeer" + ): TypedContractMethod< + [ + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + gasLimit: BigNumberish, + inboundLimit: BigNumberish + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "setThreshold" + ): TypedContractMethod< + [chain: BigNumberish, threshold: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "setTransceiver" + ): TypedContractMethod<[transceiver: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "token" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "tokenDecimals" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "transceiverAttestedToMessage" + ): TypedContractMethod< + [ + srcChain: BigNumberish, + srcAddr: BytesLike, + sequence: BigNumberish, + dstAddr: BytesLike, + payloadHash: BytesLike, + index: BigNumberish + ], + [boolean], + "view" + >; + getFunction( + nameOrSignature: "transfer(uint256,uint16,bytes32,bytes32,bool,bytes,bytes,bytes)" + ): TypedContractMethod< + [ + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + refundAddress: BytesLike, + shouldQueue: boolean, + executorQuote: BytesLike, + relayInstructions: BytesLike, + transceiverInstructions: BytesLike + ], + [bigint], + "payable" + >; + getFunction( + nameOrSignature: "transfer(uint256,uint16,bytes32,bytes,bytes,bytes)" + ): TypedContractMethod< + [ + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + executorQuote: BytesLike, + relayInstructions: BytesLike, + transceiverInstructions: BytesLike + ], + [bigint], + "payable" + >; + getFunction( + nameOrSignature: "transferOwnership" + ): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "transferPauserCapability" + ): TypedContractMethod<[newPauser: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "unpause" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "upgrade" + ): TypedContractMethod< + [newImplementation: AddressLike], + [void], + "nonpayable" + >; + + getEvent( + key: "AdminChanged" + ): TypedContractEvent< + AdminChangedEvent.InputTuple, + AdminChangedEvent.OutputTuple, + AdminChangedEvent.OutputObject + >; + getEvent( + key: "BeaconUpgraded" + ): TypedContractEvent< + BeaconUpgradedEvent.InputTuple, + BeaconUpgradedEvent.OutputTuple, + BeaconUpgradedEvent.OutputObject + >; + getEvent( + key: "InboundTransferLimitUpdated" + ): TypedContractEvent< + InboundTransferLimitUpdatedEvent.InputTuple, + InboundTransferLimitUpdatedEvent.OutputTuple, + InboundTransferLimitUpdatedEvent.OutputObject + >; + getEvent( + key: "InboundTransferQueued" + ): TypedContractEvent< + InboundTransferQueuedEvent.InputTuple, + InboundTransferQueuedEvent.OutputTuple, + InboundTransferQueuedEvent.OutputObject + >; + getEvent( + key: "Initialized" + ): TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + getEvent( + key: "MessageAttestedTo" + ): TypedContractEvent< + MessageAttestedToEvent.InputTuple, + MessageAttestedToEvent.OutputTuple, + MessageAttestedToEvent.OutputObject + >; + getEvent( + key: "NotPaused" + ): TypedContractEvent< + NotPausedEvent.InputTuple, + NotPausedEvent.OutputTuple, + NotPausedEvent.OutputObject + >; + getEvent( + key: "OutboundTransferCancelled" + ): TypedContractEvent< + OutboundTransferCancelledEvent.InputTuple, + OutboundTransferCancelledEvent.OutputTuple, + OutboundTransferCancelledEvent.OutputObject + >; + getEvent( + key: "OutboundTransferLimitUpdated" + ): TypedContractEvent< + OutboundTransferLimitUpdatedEvent.InputTuple, + OutboundTransferLimitUpdatedEvent.OutputTuple, + OutboundTransferLimitUpdatedEvent.OutputObject + >; + getEvent( + key: "OutboundTransferQueued" + ): TypedContractEvent< + OutboundTransferQueuedEvent.InputTuple, + OutboundTransferQueuedEvent.OutputTuple, + OutboundTransferQueuedEvent.OutputObject + >; + getEvent( + key: "OutboundTransferRateLimited" + ): TypedContractEvent< + OutboundTransferRateLimitedEvent.InputTuple, + OutboundTransferRateLimitedEvent.OutputTuple, + OutboundTransferRateLimitedEvent.OutputObject + >; + getEvent( + key: "OwnershipTransferred" + ): TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + getEvent( + key: "Paused" + ): TypedContractEvent< + PausedEvent.InputTuple, + PausedEvent.OutputTuple, + PausedEvent.OutputObject + >; + getEvent( + key: "PauserTransferred" + ): TypedContractEvent< + PauserTransferredEvent.InputTuple, + PauserTransferredEvent.OutputTuple, + PauserTransferredEvent.OutputObject + >; + getEvent( + key: "PeerUpdated" + ): TypedContractEvent< + PeerUpdatedEvent.InputTuple, + PeerUpdatedEvent.OutputTuple, + PeerUpdatedEvent.OutputObject + >; + getEvent( + key: "ThresholdChanged" + ): TypedContractEvent< + ThresholdChangedEvent.InputTuple, + ThresholdChangedEvent.OutputTuple, + ThresholdChangedEvent.OutputObject + >; + getEvent( + key: "TransceiverAdded" + ): TypedContractEvent< + TransceiverAddedEvent.InputTuple, + TransceiverAddedEvent.OutputTuple, + TransceiverAddedEvent.OutputObject + >; + getEvent( + key: "TransferRedeemed" + ): TypedContractEvent< + TransferRedeemedEvent.InputTuple, + TransferRedeemedEvent.OutputTuple, + TransferRedeemedEvent.OutputObject + >; + getEvent( + key: "TransferSent(bytes32,bytes32,uint256,uint256,uint16,uint64,bytes32)" + ): TypedContractEvent< + TransferSent_bytes32_bytes32_uint256_uint256_uint16_uint64_bytes32_Event.InputTuple, + TransferSent_bytes32_bytes32_uint256_uint256_uint16_uint64_bytes32_Event.OutputTuple, + TransferSent_bytes32_bytes32_uint256_uint256_uint16_uint64_bytes32_Event.OutputObject + >; + getEvent( + key: "TransferSent(bytes32)" + ): TypedContractEvent< + TransferSent_bytes32_Event.InputTuple, + TransferSent_bytes32_Event.OutputTuple, + TransferSent_bytes32_Event.OutputObject + >; + getEvent( + key: "Upgraded" + ): TypedContractEvent< + UpgradedEvent.InputTuple, + UpgradedEvent.OutputTuple, + UpgradedEvent.OutputObject + >; + + filters: { + "AdminChanged(address,address)": TypedContractEvent< + AdminChangedEvent.InputTuple, + AdminChangedEvent.OutputTuple, + AdminChangedEvent.OutputObject + >; + AdminChanged: TypedContractEvent< + AdminChangedEvent.InputTuple, + AdminChangedEvent.OutputTuple, + AdminChangedEvent.OutputObject + >; + + "BeaconUpgraded(address)": TypedContractEvent< + BeaconUpgradedEvent.InputTuple, + BeaconUpgradedEvent.OutputTuple, + BeaconUpgradedEvent.OutputObject + >; + BeaconUpgraded: TypedContractEvent< + BeaconUpgradedEvent.InputTuple, + BeaconUpgradedEvent.OutputTuple, + BeaconUpgradedEvent.OutputObject + >; + + "InboundTransferLimitUpdated(uint16,uint256,uint256)": TypedContractEvent< + InboundTransferLimitUpdatedEvent.InputTuple, + InboundTransferLimitUpdatedEvent.OutputTuple, + InboundTransferLimitUpdatedEvent.OutputObject + >; + InboundTransferLimitUpdated: TypedContractEvent< + InboundTransferLimitUpdatedEvent.InputTuple, + InboundTransferLimitUpdatedEvent.OutputTuple, + InboundTransferLimitUpdatedEvent.OutputObject + >; + + "InboundTransferQueued(bytes32)": TypedContractEvent< + InboundTransferQueuedEvent.InputTuple, + InboundTransferQueuedEvent.OutputTuple, + InboundTransferQueuedEvent.OutputObject + >; + InboundTransferQueued: TypedContractEvent< + InboundTransferQueuedEvent.InputTuple, + InboundTransferQueuedEvent.OutputTuple, + InboundTransferQueuedEvent.OutputObject + >; + + "Initialized(uint64)": TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + Initialized: TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + + "MessageAttestedTo(bytes32,address,uint8)": TypedContractEvent< + MessageAttestedToEvent.InputTuple, + MessageAttestedToEvent.OutputTuple, + MessageAttestedToEvent.OutputObject + >; + MessageAttestedTo: TypedContractEvent< + MessageAttestedToEvent.InputTuple, + MessageAttestedToEvent.OutputTuple, + MessageAttestedToEvent.OutputObject + >; + + "NotPaused(bool)": TypedContractEvent< + NotPausedEvent.InputTuple, + NotPausedEvent.OutputTuple, + NotPausedEvent.OutputObject + >; + NotPaused: TypedContractEvent< + NotPausedEvent.InputTuple, + NotPausedEvent.OutputTuple, + NotPausedEvent.OutputObject + >; + + "OutboundTransferCancelled(uint256,address,uint256)": TypedContractEvent< + OutboundTransferCancelledEvent.InputTuple, + OutboundTransferCancelledEvent.OutputTuple, + OutboundTransferCancelledEvent.OutputObject + >; + OutboundTransferCancelled: TypedContractEvent< + OutboundTransferCancelledEvent.InputTuple, + OutboundTransferCancelledEvent.OutputTuple, + OutboundTransferCancelledEvent.OutputObject + >; + + "OutboundTransferLimitUpdated(uint256,uint256)": TypedContractEvent< + OutboundTransferLimitUpdatedEvent.InputTuple, + OutboundTransferLimitUpdatedEvent.OutputTuple, + OutboundTransferLimitUpdatedEvent.OutputObject + >; + OutboundTransferLimitUpdated: TypedContractEvent< + OutboundTransferLimitUpdatedEvent.InputTuple, + OutboundTransferLimitUpdatedEvent.OutputTuple, + OutboundTransferLimitUpdatedEvent.OutputObject + >; + + "OutboundTransferQueued(uint64)": TypedContractEvent< + OutboundTransferQueuedEvent.InputTuple, + OutboundTransferQueuedEvent.OutputTuple, + OutboundTransferQueuedEvent.OutputObject + >; + OutboundTransferQueued: TypedContractEvent< + OutboundTransferQueuedEvent.InputTuple, + OutboundTransferQueuedEvent.OutputTuple, + OutboundTransferQueuedEvent.OutputObject + >; + + "OutboundTransferRateLimited(address,uint64,uint256,uint256)": TypedContractEvent< + OutboundTransferRateLimitedEvent.InputTuple, + OutboundTransferRateLimitedEvent.OutputTuple, + OutboundTransferRateLimitedEvent.OutputObject + >; + OutboundTransferRateLimited: TypedContractEvent< + OutboundTransferRateLimitedEvent.InputTuple, + OutboundTransferRateLimitedEvent.OutputTuple, + OutboundTransferRateLimitedEvent.OutputObject + >; + + "OwnershipTransferred(address,address)": TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + OwnershipTransferred: TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + + "Paused(bool)": TypedContractEvent< + PausedEvent.InputTuple, + PausedEvent.OutputTuple, + PausedEvent.OutputObject + >; + Paused: TypedContractEvent< + PausedEvent.InputTuple, + PausedEvent.OutputTuple, + PausedEvent.OutputObject + >; + + "PauserTransferred(address,address)": TypedContractEvent< + PauserTransferredEvent.InputTuple, + PauserTransferredEvent.OutputTuple, + PauserTransferredEvent.OutputObject + >; + PauserTransferred: TypedContractEvent< + PauserTransferredEvent.InputTuple, + PauserTransferredEvent.OutputTuple, + PauserTransferredEvent.OutputObject + >; + + "PeerUpdated(uint16,bytes32,uint8,bytes32,uint8)": TypedContractEvent< + PeerUpdatedEvent.InputTuple, + PeerUpdatedEvent.OutputTuple, + PeerUpdatedEvent.OutputObject + >; + PeerUpdated: TypedContractEvent< + PeerUpdatedEvent.InputTuple, + PeerUpdatedEvent.OutputTuple, + PeerUpdatedEvent.OutputObject + >; + + "ThresholdChanged(uint16,uint8,uint8)": TypedContractEvent< + ThresholdChangedEvent.InputTuple, + ThresholdChangedEvent.OutputTuple, + ThresholdChangedEvent.OutputObject + >; + ThresholdChanged: TypedContractEvent< + ThresholdChangedEvent.InputTuple, + ThresholdChangedEvent.OutputTuple, + ThresholdChangedEvent.OutputObject + >; + + "TransceiverAdded(address,uint256)": TypedContractEvent< + TransceiverAddedEvent.InputTuple, + TransceiverAddedEvent.OutputTuple, + TransceiverAddedEvent.OutputObject + >; + TransceiverAdded: TypedContractEvent< + TransceiverAddedEvent.InputTuple, + TransceiverAddedEvent.OutputTuple, + TransceiverAddedEvent.OutputObject + >; + + "TransferRedeemed(bytes32)": TypedContractEvent< + TransferRedeemedEvent.InputTuple, + TransferRedeemedEvent.OutputTuple, + TransferRedeemedEvent.OutputObject + >; + TransferRedeemed: TypedContractEvent< + TransferRedeemedEvent.InputTuple, + TransferRedeemedEvent.OutputTuple, + TransferRedeemedEvent.OutputObject + >; + + "TransferSent(bytes32,bytes32,uint256,uint256,uint16,uint64,bytes32)": TypedContractEvent< + TransferSent_bytes32_bytes32_uint256_uint256_uint16_uint64_bytes32_Event.InputTuple, + TransferSent_bytes32_bytes32_uint256_uint256_uint16_uint64_bytes32_Event.OutputTuple, + TransferSent_bytes32_bytes32_uint256_uint256_uint16_uint64_bytes32_Event.OutputObject + >; + "TransferSent(bytes32)": TypedContractEvent< + TransferSent_bytes32_Event.InputTuple, + TransferSent_bytes32_Event.OutputTuple, + TransferSent_bytes32_Event.OutputObject + >; + + "Upgraded(address)": TypedContractEvent< + UpgradedEvent.InputTuple, + UpgradedEvent.OutputTuple, + UpgradedEvent.OutputObject + >; + Upgraded: TypedContractEvent< + UpgradedEvent.InputTuple, + UpgradedEvent.OutputTuple, + UpgradedEvent.OutputObject + >; + }; +} diff --git a/evm/ts/src/ethers-contracts/2_0_0/common.ts b/evm/ts/src/ethers-contracts/2_0_0/common.ts new file mode 100644 index 000000000..56b5f21e9 --- /dev/null +++ b/evm/ts/src/ethers-contracts/2_0_0/common.ts @@ -0,0 +1,131 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + FunctionFragment, + Typed, + EventFragment, + ContractTransaction, + ContractTransactionResponse, + DeferredTopicFilter, + EventLog, + TransactionRequest, + LogDescription, +} from "ethers"; + +export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> + extends DeferredTopicFilter {} + +export interface TypedContractEvent< + InputTuple extends Array = any, + OutputTuple extends Array = any, + OutputObject = any +> { + (...args: Partial): TypedDeferredTopicFilter< + TypedContractEvent + >; + name: string; + fragment: EventFragment; + getFragment(...args: Partial): EventFragment; +} + +type __TypechainAOutputTuple = T extends TypedContractEvent< + infer _U, + infer W +> + ? W + : never; +type __TypechainOutputObject = T extends TypedContractEvent< + infer _U, + infer _W, + infer V +> + ? V + : never; + +export interface TypedEventLog + extends Omit { + args: __TypechainAOutputTuple & __TypechainOutputObject; +} + +export interface TypedLogDescription + extends Omit { + args: __TypechainAOutputTuple & __TypechainOutputObject; +} + +export type TypedListener = ( + ...listenerArg: [ + ...__TypechainAOutputTuple, + TypedEventLog, + ...undefined[] + ] +) => void; + +export type MinEthersFactory = { + deploy(...a: ARGS[]): Promise; +}; + +export type GetContractTypeFromFactory = F extends MinEthersFactory< + infer C, + any +> + ? C + : never; +export type GetARGsTypeFromFactory = F extends MinEthersFactory + ? Parameters + : never; + +export type StateMutability = "nonpayable" | "payable" | "view"; + +export type BaseOverrides = Omit; +export type NonPayableOverrides = Omit< + BaseOverrides, + "value" | "blockTag" | "enableCcipRead" +>; +export type PayableOverrides = Omit< + BaseOverrides, + "blockTag" | "enableCcipRead" +>; +export type ViewOverrides = Omit; +export type Overrides = S extends "nonpayable" + ? NonPayableOverrides + : S extends "payable" + ? PayableOverrides + : ViewOverrides; + +export type PostfixOverrides, S extends StateMutability> = + | A + | [...A, Overrides]; +export type ContractMethodArgs< + A extends Array, + S extends StateMutability +> = PostfixOverrides<{ [I in keyof A]-?: A[I] | Typed }, S>; + +export type DefaultReturnType = R extends Array ? R[0] : R; + +// export interface ContractMethod = Array, R = any, D extends R | ContractTransactionResponse = R | ContractTransactionResponse> { +export interface TypedContractMethod< + A extends Array = Array, + R = any, + S extends StateMutability = "payable" +> { + (...args: ContractMethodArgs): S extends "view" + ? Promise> + : Promise; + + name: string; + + fragment: FunctionFragment; + + getFragment(...args: ContractMethodArgs): FunctionFragment; + + populateTransaction( + ...args: ContractMethodArgs + ): Promise; + staticCall( + ...args: ContractMethodArgs + ): Promise>; + send(...args: ContractMethodArgs): Promise; + estimateGas(...args: ContractMethodArgs): Promise; + staticCallResult(...args: ContractMethodArgs): Promise; +} diff --git a/evm/ts/src/ethers-contracts/2_0_0/factories/NttManager__factory.ts b/evm/ts/src/ethers-contracts/2_0_0/factories/NttManager__factory.ts new file mode 100644 index 000000000..6e4c3c4d4 --- /dev/null +++ b/evm/ts/src/ethers-contracts/2_0_0/factories/NttManager__factory.ts @@ -0,0 +1,2147 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { + Contract, + ContractFactory, + ContractTransactionResponse, + Interface, +} from "ethers"; +import type { + Signer, + BigNumberish, + AddressLike, + ContractDeployTransaction, + ContractRunner, +} from "ethers"; +import type { NonPayableOverrides } from "../common.js"; +import type { NttManager, NttManagerInterface } from "../NttManager.js"; + +const _abi = [ + { + type: "constructor", + inputs: [ + { + name: "_endpoint", + type: "address", + internalType: "address", + }, + { + name: "_executor", + type: "address", + internalType: "address", + }, + { + name: "_token", + type: "address", + internalType: "address", + }, + { + name: "_mode", + type: "uint8", + internalType: "enum IManagerBase.Mode", + }, + { + name: "_chainId", + type: "uint16", + internalType: "uint16", + }, + { + name: "_rateLimitDuration", + type: "uint64", + internalType: "uint64", + }, + { + name: "_skipRateLimiting", + type: "bool", + internalType: "bool", + }, + ], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "NTT_MANAGER_VERSION", + inputs: [], + outputs: [ + { + name: "", + type: "string", + internalType: "string", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "cancelOutboundQueuedTransfer", + inputs: [ + { + name: "messageSequence", + type: "uint64", + internalType: "uint64", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "chainId", + inputs: [], + outputs: [ + { + name: "", + type: "uint16", + internalType: "uint16", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "completeInboundQueuedTransfer", + inputs: [ + { + name: "digest", + type: "bytes32", + internalType: "bytes32", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "completeOutboundQueuedTransfer", + inputs: [ + { + name: "messageSequence", + type: "uint64", + internalType: "uint64", + }, + ], + outputs: [ + { + name: "", + type: "uint64", + internalType: "uint64", + }, + ], + stateMutability: "payable", + }, + { + type: "function", + name: "disableRecvTransceiver", + inputs: [ + { + name: "chain", + type: "uint16", + internalType: "uint16", + }, + { + name: "transceiver", + type: "address", + internalType: "address", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "disableSendTransceiver", + inputs: [ + { + name: "chain", + type: "uint16", + internalType: "uint16", + }, + { + name: "transceiver", + type: "address", + internalType: "address", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "enableRecvTransceiver", + inputs: [ + { + name: "chain", + type: "uint16", + internalType: "uint16", + }, + { + name: "transceiver", + type: "address", + internalType: "address", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "enableSendTransceiver", + inputs: [ + { + name: "chain", + type: "uint16", + internalType: "uint16", + }, + { + name: "transceiver", + type: "address", + internalType: "address", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "endpoint", + inputs: [], + outputs: [ + { + name: "", + type: "address", + internalType: "contract IEndpointIntegrator", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "executeMsg", + inputs: [ + { + name: "sourceChainId", + type: "uint16", + internalType: "uint16", + }, + { + name: "sourceNttManagerAddress", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "epSeq", + type: "uint64", + internalType: "uint64", + }, + { + name: "payload", + type: "bytes", + internalType: "bytes", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "executor", + inputs: [], + outputs: [ + { + name: "", + type: "address", + internalType: "contract IExecutor", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getCurrentInboundCapacity", + inputs: [ + { + name: "chainId_", + type: "uint16", + internalType: "uint16", + }, + ], + outputs: [ + { + name: "", + type: "uint256", + internalType: "uint256", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getCurrentOutboundCapacity", + inputs: [], + outputs: [ + { + name: "", + type: "uint256", + internalType: "uint256", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getInboundLimitParams", + inputs: [ + { + name: "chainId_", + type: "uint16", + internalType: "uint16", + }, + ], + outputs: [ + { + name: "", + type: "tuple", + internalType: "struct IRateLimiter.RateLimitParams", + components: [ + { + name: "limit", + type: "uint72", + internalType: "TrimmedAmount", + }, + { + name: "currentCapacity", + type: "uint72", + internalType: "TrimmedAmount", + }, + { + name: "lastTxTimestamp", + type: "uint64", + internalType: "uint64", + }, + ], + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getInboundQueuedTransfer", + inputs: [ + { + name: "digest", + type: "bytes32", + internalType: "bytes32", + }, + ], + outputs: [ + { + name: "", + type: "tuple", + internalType: "struct IRateLimiter.InboundQueuedTransfer", + components: [ + { + name: "amount", + type: "uint72", + internalType: "TrimmedAmount", + }, + { + name: "txTimestamp", + type: "uint64", + internalType: "uint64", + }, + { + name: "recipient", + type: "address", + internalType: "address", + }, + ], + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getMigratesImmutables", + inputs: [], + outputs: [ + { + name: "", + type: "bool", + internalType: "bool", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getMode", + inputs: [], + outputs: [ + { + name: "", + type: "uint8", + internalType: "uint8", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getOutboundLimitParams", + inputs: [], + outputs: [ + { + name: "", + type: "tuple", + internalType: "struct IRateLimiter.RateLimitParams", + components: [ + { + name: "limit", + type: "uint72", + internalType: "TrimmedAmount", + }, + { + name: "currentCapacity", + type: "uint72", + internalType: "TrimmedAmount", + }, + { + name: "lastTxTimestamp", + type: "uint64", + internalType: "uint64", + }, + ], + }, + ], + stateMutability: "pure", + }, + { + type: "function", + name: "getOutboundQueuedTransfer", + inputs: [ + { + name: "queueSequence", + type: "uint64", + internalType: "uint64", + }, + ], + outputs: [ + { + name: "", + type: "tuple", + internalType: "struct IRateLimiter.OutboundQueuedTransfer", + components: [ + { + name: "recipient", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "refundAddress", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "amount", + type: "uint72", + internalType: "TrimmedAmount", + }, + { + name: "txTimestamp", + type: "uint64", + internalType: "uint64", + }, + { + name: "recipientChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "sender", + type: "address", + internalType: "address", + }, + { + name: "executorQuote", + type: "bytes", + internalType: "bytes", + }, + { + name: "relayInstructions", + type: "bytes", + internalType: "bytes", + }, + { + name: "transceiverInstructions", + type: "bytes", + internalType: "bytes", + }, + ], + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getPeer", + inputs: [ + { + name: "chainId_", + type: "uint16", + internalType: "uint16", + }, + ], + outputs: [ + { + name: "", + type: "tuple", + internalType: "struct INttManager.NttManagerPeer", + components: [ + { + name: "peerAddress", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "tokenDecimals", + type: "uint8", + internalType: "uint8", + }, + { + name: "gasLimit", + type: "uint128", + internalType: "uint128", + }, + ], + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "getThreshold", + inputs: [ + { + name: "chain", + type: "uint16", + internalType: "uint16", + }, + ], + outputs: [ + { + name: "", + type: "uint8", + internalType: "uint8", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "initialize", + inputs: [], + outputs: [], + stateMutability: "payable", + }, + { + type: "function", + name: "isMessageApproved", + inputs: [ + { + name: "srcChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "srcAddr", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "sequence", + type: "uint64", + internalType: "uint64", + }, + { + name: "dstAddr", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "payloadHash", + type: "bytes32", + internalType: "bytes32", + }, + ], + outputs: [ + { + name: "", + type: "bool", + internalType: "bool", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "isMessageExecuted", + inputs: [ + { + name: "srcChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "srcAddr", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "sequence", + type: "uint64", + internalType: "uint64", + }, + { + name: "dstAddr", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "payloadHash", + type: "bytes32", + internalType: "bytes32", + }, + ], + outputs: [ + { + name: "", + type: "bool", + internalType: "bool", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "isPaused", + inputs: [], + outputs: [ + { + name: "", + type: "bool", + internalType: "bool", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "messageAttestations", + inputs: [ + { + name: "srcChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "srcAddr", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "sequence", + type: "uint64", + internalType: "uint64", + }, + { + name: "dstAddr", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "payloadHash", + type: "bytes32", + internalType: "bytes32", + }, + ], + outputs: [ + { + name: "count", + type: "uint8", + internalType: "uint8", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "migrate", + inputs: [], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "mode", + inputs: [], + outputs: [ + { + name: "", + type: "uint8", + internalType: "enum IManagerBase.Mode", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "nextMessageSequence", + inputs: [], + outputs: [ + { + name: "", + type: "uint64", + internalType: "uint64", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "owner", + inputs: [], + outputs: [ + { + name: "", + type: "address", + internalType: "address", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "pause", + inputs: [], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "pauser", + inputs: [], + outputs: [ + { + name: "", + type: "address", + internalType: "address", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "quoteDeliveryPrice", + inputs: [ + { + name: "recipientChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "transceiverInstructions", + type: "bytes", + internalType: "bytes", + }, + ], + outputs: [ + { + name: "", + type: "uint256", + internalType: "uint256", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "rateLimitDuration", + inputs: [], + outputs: [ + { + name: "", + type: "uint64", + internalType: "uint64", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "setGasLimit", + inputs: [ + { + name: "peerChainId", + type: "uint16", + internalType: "uint16", + }, + { + name: "gasLimit", + type: "uint128", + internalType: "uint128", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "setInboundLimit", + inputs: [ + { + name: "limit", + type: "uint256", + internalType: "uint256", + }, + { + name: "chainId_", + type: "uint16", + internalType: "uint16", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "setOutboundLimit", + inputs: [ + { + name: "limit", + type: "uint256", + internalType: "uint256", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "setPeer", + inputs: [ + { + name: "peerChainId", + type: "uint16", + internalType: "uint16", + }, + { + name: "peerContract", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "decimals", + type: "uint8", + internalType: "uint8", + }, + { + name: "gasLimit", + type: "uint128", + internalType: "uint128", + }, + { + name: "inboundLimit", + type: "uint256", + internalType: "uint256", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "setThreshold", + inputs: [ + { + name: "chain", + type: "uint16", + internalType: "uint16", + }, + { + name: "threshold", + type: "uint8", + internalType: "uint8", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "setTransceiver", + inputs: [ + { + name: "transceiver", + type: "address", + internalType: "address", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "token", + inputs: [], + outputs: [ + { + name: "", + type: "address", + internalType: "address", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "tokenDecimals", + inputs: [], + outputs: [ + { + name: "", + type: "uint8", + internalType: "uint8", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "transceiverAttestedToMessage", + inputs: [ + { + name: "srcChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "srcAddr", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "sequence", + type: "uint64", + internalType: "uint64", + }, + { + name: "dstAddr", + type: "bytes32", + internalType: "UniversalAddress", + }, + { + name: "payloadHash", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "index", + type: "uint8", + internalType: "uint8", + }, + ], + outputs: [ + { + name: "", + type: "bool", + internalType: "bool", + }, + ], + stateMutability: "view", + }, + { + type: "function", + name: "transfer", + inputs: [ + { + name: "amount", + type: "uint256", + internalType: "uint256", + }, + { + name: "recipientChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "recipient", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "refundAddress", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "shouldQueue", + type: "bool", + internalType: "bool", + }, + { + name: "executorQuote", + type: "bytes", + internalType: "bytes", + }, + { + name: "relayInstructions", + type: "bytes", + internalType: "bytes", + }, + { + name: "transceiverInstructions", + type: "bytes", + internalType: "bytes", + }, + ], + outputs: [ + { + name: "", + type: "uint64", + internalType: "uint64", + }, + ], + stateMutability: "payable", + }, + { + type: "function", + name: "transfer", + inputs: [ + { + name: "amount", + type: "uint256", + internalType: "uint256", + }, + { + name: "recipientChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "recipient", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "executorQuote", + type: "bytes", + internalType: "bytes", + }, + { + name: "relayInstructions", + type: "bytes", + internalType: "bytes", + }, + { + name: "transceiverInstructions", + type: "bytes", + internalType: "bytes", + }, + ], + outputs: [ + { + name: "", + type: "uint64", + internalType: "uint64", + }, + ], + stateMutability: "payable", + }, + { + type: "function", + name: "transferOwnership", + inputs: [ + { + name: "newOwner", + type: "address", + internalType: "address", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "transferPauserCapability", + inputs: [ + { + name: "newPauser", + type: "address", + internalType: "address", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "unpause", + inputs: [], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "function", + name: "upgrade", + inputs: [ + { + name: "newImplementation", + type: "address", + internalType: "address", + }, + ], + outputs: [], + stateMutability: "nonpayable", + }, + { + type: "event", + name: "AdminChanged", + inputs: [ + { + name: "previousAdmin", + type: "address", + indexed: false, + internalType: "address", + }, + { + name: "newAdmin", + type: "address", + indexed: false, + internalType: "address", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "BeaconUpgraded", + inputs: [ + { + name: "beacon", + type: "address", + indexed: true, + internalType: "address", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "InboundTransferLimitUpdated", + inputs: [ + { + name: "chainId", + type: "uint16", + indexed: true, + internalType: "uint16", + }, + { + name: "oldLimit", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + { + name: "newLimit", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "InboundTransferQueued", + inputs: [ + { + name: "digest", + type: "bytes32", + indexed: false, + internalType: "bytes32", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "Initialized", + inputs: [ + { + name: "version", + type: "uint64", + indexed: false, + internalType: "uint64", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "MessageAttestedTo", + inputs: [ + { + name: "digest", + type: "bytes32", + indexed: false, + internalType: "bytes32", + }, + { + name: "transceiver", + type: "address", + indexed: false, + internalType: "address", + }, + { + name: "index", + type: "uint8", + indexed: false, + internalType: "uint8", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "NotPaused", + inputs: [ + { + name: "notPaused", + type: "bool", + indexed: false, + internalType: "bool", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "OutboundTransferCancelled", + inputs: [ + { + name: "sequence", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + { + name: "recipient", + type: "address", + indexed: false, + internalType: "address", + }, + { + name: "amount", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "OutboundTransferLimitUpdated", + inputs: [ + { + name: "oldLimit", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + { + name: "newLimit", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "OutboundTransferQueued", + inputs: [ + { + name: "queueSequence", + type: "uint64", + indexed: false, + internalType: "uint64", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "OutboundTransferRateLimited", + inputs: [ + { + name: "sender", + type: "address", + indexed: true, + internalType: "address", + }, + { + name: "sequence", + type: "uint64", + indexed: false, + internalType: "uint64", + }, + { + name: "amount", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + { + name: "currentCapacity", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "OwnershipTransferred", + inputs: [ + { + name: "previousOwner", + type: "address", + indexed: true, + internalType: "address", + }, + { + name: "newOwner", + type: "address", + indexed: true, + internalType: "address", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "Paused", + inputs: [ + { + name: "paused", + type: "bool", + indexed: false, + internalType: "bool", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "PauserTransferred", + inputs: [ + { + name: "oldPauser", + type: "address", + indexed: true, + internalType: "address", + }, + { + name: "newPauser", + type: "address", + indexed: true, + internalType: "address", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "PeerUpdated", + inputs: [ + { + name: "chainId_", + type: "uint16", + indexed: true, + internalType: "uint16", + }, + { + name: "oldPeerContract", + type: "bytes32", + indexed: false, + internalType: "bytes32", + }, + { + name: "oldPeerDecimals", + type: "uint8", + indexed: false, + internalType: "uint8", + }, + { + name: "peerContract", + type: "bytes32", + indexed: false, + internalType: "bytes32", + }, + { + name: "peerDecimals", + type: "uint8", + indexed: false, + internalType: "uint8", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "ThresholdChanged", + inputs: [ + { + name: "chainId", + type: "uint16", + indexed: false, + internalType: "uint16", + }, + { + name: "oldThreshold", + type: "uint8", + indexed: false, + internalType: "uint8", + }, + { + name: "threshold", + type: "uint8", + indexed: false, + internalType: "uint8", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "TransceiverAdded", + inputs: [ + { + name: "transceiver", + type: "address", + indexed: false, + internalType: "address", + }, + { + name: "transceiversNum", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "TransferRedeemed", + inputs: [ + { + name: "digest", + type: "bytes32", + indexed: true, + internalType: "bytes32", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "TransferSent", + inputs: [ + { + name: "recipient", + type: "bytes32", + indexed: true, + internalType: "bytes32", + }, + { + name: "refundAddress", + type: "bytes32", + indexed: true, + internalType: "bytes32", + }, + { + name: "amount", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + { + name: "fee", + type: "uint256", + indexed: false, + internalType: "uint256", + }, + { + name: "recipientChain", + type: "uint16", + indexed: false, + internalType: "uint16", + }, + { + name: "msgSequence", + type: "uint64", + indexed: false, + internalType: "uint64", + }, + { + name: "msgHash", + type: "bytes32", + indexed: false, + internalType: "bytes32", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "TransferSent", + inputs: [ + { + name: "digest", + type: "bytes32", + indexed: true, + internalType: "bytes32", + }, + ], + anonymous: false, + }, + { + type: "event", + name: "Upgraded", + inputs: [ + { + name: "implementation", + type: "address", + indexed: true, + internalType: "address", + }, + ], + anonymous: false, + }, + { + type: "error", + name: "BurnAmountDifferentThanBalanceDiff", + inputs: [ + { + name: "burnAmount", + type: "uint256", + internalType: "uint256", + }, + { + name: "balanceDiff", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "CancellerNotSender", + inputs: [ + { + name: "canceller", + type: "address", + internalType: "address", + }, + { + name: "sender", + type: "address", + internalType: "address", + }, + ], + }, + { + type: "error", + name: "CapacityCannotExceedLimit", + inputs: [ + { + name: "newCurrentCapacity", + type: "uint72", + internalType: "TrimmedAmount", + }, + { + name: "newLimit", + type: "uint72", + internalType: "TrimmedAmount", + }, + ], + }, + { + type: "error", + name: "DeliveryPaymentTooLow", + inputs: [ + { + name: "requiredPayment", + type: "uint256", + internalType: "uint256", + }, + { + name: "providedPayment", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "InboundQueuedTransferNotFound", + inputs: [ + { + name: "digest", + type: "bytes32", + internalType: "bytes32", + }, + ], + }, + { + type: "error", + name: "InboundQueuedTransferStillQueued", + inputs: [ + { + name: "digest", + type: "bytes32", + internalType: "bytes32", + }, + { + name: "transferTimestamp", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "InvalidFork", + inputs: [ + { + name: "evmChainId", + type: "uint256", + internalType: "uint256", + }, + { + name: "blockChainId", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "InvalidGasLimitZero", + inputs: [ + { + name: "destChain", + type: "uint16", + internalType: "uint16", + }, + ], + }, + { + type: "error", + name: "InvalidInitialization", + inputs: [], + }, + { + type: "error", + name: "InvalidMode", + inputs: [ + { + name: "mode", + type: "uint8", + internalType: "uint8", + }, + ], + }, + { + type: "error", + name: "InvalidPauser", + inputs: [ + { + name: "account", + type: "address", + internalType: "address", + }, + ], + }, + { + type: "error", + name: "InvalidPeer", + inputs: [ + { + name: "chainId", + type: "uint16", + internalType: "uint16", + }, + { + name: "peerAddress", + type: "bytes32", + internalType: "bytes32", + }, + ], + }, + { + type: "error", + name: "InvalidPeerChainIdZero", + inputs: [], + }, + { + type: "error", + name: "InvalidPeerDecimals", + inputs: [], + }, + { + type: "error", + name: "InvalidPeerSameChainId", + inputs: [], + }, + { + type: "error", + name: "InvalidPeerZeroAddress", + inputs: [], + }, + { + type: "error", + name: "InvalidRecipient", + inputs: [], + }, + { + type: "error", + name: "InvalidRefundAddress", + inputs: [], + }, + { + type: "error", + name: "InvalidTargetChain", + inputs: [ + { + name: "targetChain", + type: "uint16", + internalType: "uint16", + }, + { + name: "thisChain", + type: "uint16", + internalType: "uint16", + }, + ], + }, + { + type: "error", + name: "MessageNotApproved", + inputs: [ + { + name: "msgHash", + type: "bytes32", + internalType: "bytes32", + }, + ], + }, + { + type: "error", + name: "NoEnabledTransceivers", + inputs: [], + }, + { + type: "error", + name: "NotAnEvmAddress", + inputs: [ + { + name: "", + type: "bytes32", + internalType: "bytes32", + }, + ], + }, + { + type: "error", + name: "NotAnEvmAddress", + inputs: [ + { + name: "", + type: "bytes32", + internalType: "bytes32", + }, + ], + }, + { + type: "error", + name: "NotEnoughCapacity", + inputs: [ + { + name: "currentCapacity", + type: "uint256", + internalType: "uint256", + }, + { + name: "amount", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "NotImplemented", + inputs: [], + }, + { + type: "error", + name: "NotInitializing", + inputs: [], + }, + { + type: "error", + name: "NotMigrating", + inputs: [], + }, + { + type: "error", + name: "NumberOfDecimalsNotEqual", + inputs: [ + { + name: "decimals", + type: "uint8", + internalType: "uint8", + }, + { + name: "decimalsOther", + type: "uint8", + internalType: "uint8", + }, + ], + }, + { + type: "error", + name: "OnlyDelegateCall", + inputs: [], + }, + { + type: "error", + name: "OutboundQueuedTransferNotFound", + inputs: [ + { + name: "queueSequence", + type: "uint64", + internalType: "uint64", + }, + ], + }, + { + type: "error", + name: "OutboundQueuedTransferStillQueued", + inputs: [ + { + name: "queueSequence", + type: "uint64", + internalType: "uint64", + }, + { + name: "transferTimestamp", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "OwnableInvalidOwner", + inputs: [ + { + name: "owner", + type: "address", + internalType: "address", + }, + ], + }, + { + type: "error", + name: "OwnableUnauthorizedAccount", + inputs: [ + { + name: "account", + type: "address", + internalType: "address", + }, + ], + }, + { + type: "error", + name: "PeerNotRegistered", + inputs: [ + { + name: "chainId", + type: "uint16", + internalType: "uint16", + }, + ], + }, + { + type: "error", + name: "ReentrancyGuardReentrantCall", + inputs: [], + }, + { + type: "error", + name: "RefundFailed", + inputs: [ + { + name: "refundAmount", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "RequireContractIsNotPaused", + inputs: [], + }, + { + type: "error", + name: "RequireContractIsPaused", + inputs: [], + }, + { + type: "error", + name: "RetrievedIncorrectRegisteredTransceivers", + inputs: [ + { + name: "retrieved", + type: "uint256", + internalType: "uint256", + }, + { + name: "registered", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "StaticcallFailed", + inputs: [], + }, + { + type: "error", + name: "ThresholdNotMet", + inputs: [ + { + name: "threshold", + type: "uint8", + internalType: "uint8", + }, + { + name: "numAttested", + type: "uint8", + internalType: "uint8", + }, + ], + }, + { + type: "error", + name: "ThresholdTooHigh", + inputs: [ + { + name: "threshold", + type: "uint256", + internalType: "uint256", + }, + { + name: "transceivers", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "TransceiverAlreadyAttestedToMessage", + inputs: [ + { + name: "nttManagerMessageHash", + type: "bytes32", + internalType: "bytes32", + }, + ], + }, + { + type: "error", + name: "TransferAmountHasDust", + inputs: [ + { + name: "amount", + type: "uint256", + internalType: "uint256", + }, + { + name: "dust", + type: "uint256", + internalType: "uint256", + }, + ], + }, + { + type: "error", + name: "UndefinedRateLimiting", + inputs: [], + }, + { + type: "error", + name: "UnexpectedDeployer", + inputs: [ + { + name: "expectedOwner", + type: "address", + internalType: "address", + }, + { + name: "owner", + type: "address", + internalType: "address", + }, + ], + }, + { + type: "error", + name: "UnexpectedMsgValue", + inputs: [], + }, + { + type: "error", + name: "ZeroAmount", + inputs: [], + }, + { + type: "error", + name: "ZeroThreshold", + inputs: [], + }, +] as const; + +const _bytecode = + "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__$93083e246e55d56d98f3df2872cd16bfd0$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$93083e246e55d56d98f3df2872cd16bfd0$__5af493841561352a578194613485575b505061ffff80606085015116907f00000000000000000000000000000000000000000000000000000000000000001680820361346a5750508061341c6133fa614d87565b806134178188516001600160401b0360ff82169160081c16615a63565b615abe565b930151908160a01c61345357506001600160a01b031690613441908290849086613536565b61344e5761318892614bd5565b505050565b60249250519063033b960d60e41b82526004820152fd5b6044925191631ee5902560e11b835260048301526024820152fd5b909193503d8083833e6134988183612d7b565b81019060208183031261063b5780516001600160401b0391828211610f16570160a08184031261095d578551936134ce85612d45565b81516001600160481b038116810361063f57855260208201516020860152868201518786015261350060608301613351565b60608601526080820151928311610298575061351d9291016132e8565b60808201529138806133b6565b509051903d90823e3d90fd5b90926001600160401b0360007f00000000000000000000000000000000000000000000000000000000000000008216156136bf57506135736132c9565b5061ffff8516600052600080516020615cc683398151915260205261359e612bd260406000206151cf565b6135a885826159ba565b81808660081c169160081c16105b6135d4575050506135ca6135cf9282615794565b61566e565b600090565b7f7f63c9251d82a933210c2b6d0b0f116252c3c116788120e64e8e8215df6f31629450906001602094926136996040519161360e83612d2a565b6001600160481b03958616835242811688840190815260a085901b859003958616604080860191825260008a81527f4e8909a01183a67951f5a6147d6e76ed02ea890c72afea01a9edee91edc609b88c522094518554925170ffffffffffffffffffffffffffffffffff19909316981697909717911660481b67ffffffffffffffff60481b16178255565b019151166bffffffffffffffffffffffff60a01b825416179055604051908152a1600190565b6135b6565b90600182811c921680156136f4575b60208310146136de57565b634e487b7160e01b600052602260045260246000fd5b91607f16916136d3565b9060405191826000825492613712846136c4565b90818452600194858116908160001461377f575060011461373c575b505061318892500383612d7b565b9093915060005260209081600020936000915b8183106137675750506131889350820101388061372e565b8554888401850152948501948794509183019161374f565b91505061318894506020925060ff191682840152151560051b820101388061372e565b8181106137ad575050565b600081556001016137a2565b6137c381546136c4565b90816137cd575050565b81601f600093116001146137df575055565b9080839182526137fe601f60208420940160051c8401600185016137a2565b5555565b6006613188916000815560006001820155600060028201556000600382015561382d600482016137b9565b613839600582016137b9565b016137b9565b919594939290956000968315613af2578115613ae0578215613ace577f000000000000000000000000000000000000000000000000000000000000000097613887308a614e07565b60018060a01b038a169060409a6138cc8c516323b872dd60e01b6020820152602499338b8301523060448301526064820152606481526138c681612d45565b84613d63565b6138df826138da3084614e07565b612ee9565b927f00000000000000000000000000000000000000000000000000000000000000006002811015613abb57600114613a39575b50505061ffff8316600052600080516020615c2683398151915260205260ff60018b6000200154168015613a285761395361394b614d87565b918284615abe565b9a6139706001600160401b03928d8460ff82169160081c16615a63565b808403613a025750507fad78307a8b51804c575f26039dcb87c58925afb3b7c08732f3b21b942aed7a769081549080821698818a146139f05750896139d695898f958f958f95988c928f9a928d9360018d0116906001600160401b031916179055613f0b565b6139e557612e09973394614567565b505050935050505090565b634e487b7160e01b8652601160045285fd5b60449189613a11869384612ee9565b9151926338f831a560e11b84526004840152820152fd5b8a5163ade64f0b60e01b8152600490fd5b803b15610f16578480918a8f5180948193630852cd8d60e31b83528960048401525af18015613ab157613a9c575b50613a73903090614e07565b808203613a805780613912565b60449250878c51926302156a8f60e01b84526004840152820152fd5b93613aaa613a739295612ce5565b9390613a67565b8d513d87823e3d90fd5b634e487b7160e01b865260216004528986fd5b60405163717f139360e11b8152600490fd5b604051634e46966960e11b8152600490fd5b604051631f2a200560e01b8152600490fd5b97969594939291906000938915613af2578215613ae0578315613ace57613b93997f000000000000000000000000000000000000000000000000000000000000000090613b513083614e07565b60018060a01b0383169260409d8e516323b872dd60e01b60208201526024943386830152306044830152606482015260648152613b8d81612d45565b85613d63565b613ba1826138da3084614e07565b937f00000000000000000000000000000000000000000000000000000000000000006002811015613d5057600114613cce575b50505061ffff8416600052600080516020615c2683398151915260205260ff60018d600020015416908115613cbd57613c369b9c613c1b613c13614d87565b938486615abe565b9c8d936001600160401b03948560ff82169160081c16615a63565b808503613cae5750507fad78307a8b51804c575f26039dcb87c58925afb3b7c08732f3b21b942aed7a769182549181831699828b14613c9d575050896139d695898f958f958f95988c928f9a928d9360018d0116906001600160401b031916179055613f0b565b634e487b7160e01b81526011600452fd5b90604492613a11869384612ee9565b8c5163ade64f0b60e01b8152600490fd5b803b156109e657898f918582935180948193630852cd8d60e31b83528a60048401525af18015613d4557613d30575b50613d09903090614e07565b808203613d165780613bd4565b6044928e51926302156a8f60e01b84526004840152820152fd5b98613d3e613d09929a612ce5565b9890613cfd565b508e513d8b823e3d90fd5b634e487b7160e01b8b526021600452848bfd5b604051613dc1916001600160a01b0316613d7c82612d60565b6000806020958685527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c656487860152868151910182855af1613dbb613e42565b91613e72565b805180613dcd57505050565b818391810103126105ad5781613de39101612f2e565b15613deb5750565b6084906040519062461bcd60e51b82526004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152fd5b3d15613e6d573d90613e5382612d9c565b91613e616040519384612d7b565b82523d6000602084013e565b606090565b91929015613ed45750815115613e86575090565b3b15613e8f5790565b60405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606490fd5b825190915015613ee75750805190602001fd5b60405162461bcd60e51b81526020600482015290819061060f906024830190612cc0565b9998959097999691929493968a68ffffffffffffffff0060ff613f51613f4c613f356117d8614d87565b856001600160401b03858398169160081c16615a63565b615574565b60081b919091169116179760007f00000000000000000000000000000000000000000000000000000000000000006001600160401b0316156145625750613f966132c9565b50613fa2612bd2615187565b613fac8a826159ba565b6001600160401b03808b60081c169160081c16105b81158061455b575b614535578161452d575b50613ff357505050505050506135cf929350613fee816155dc565b615847565b6141339294969893959750906001600160401b03916140317f0000000000000000000000000000000000000000000000000000000000000000615970565b61403961522f565b60405191848c168352602083015260408201527ff33512b84e24a49905c26c6991942fc5a9652411769fc1e448f967cdb049f08a60603392a26040519a8b9661408188612d0e565b87526020870198895260408701956001600160481b0380921687526060880192844216845261ffff60808a019716875260e060a08a0199338b5260c081019b8c5201526101008d0152828a16600052600080516020615ce68339815191526020526040600020988c518a555160018a0155600289019551166001600160481b03198654161785555116839067ffffffffffffffff60481b82549160481b169067ffffffffffffffff60481b1916179055565b51815461ffff60881b191660889190911b61ffff60881b16179055516003830180546001600160a01b0319166001600160a01b0392909216919091179055518051906001600160401b038211612cf857819061419260048501546136c4565b601f81116144f8575b50602090601f83116001146144865760009261447b575b50508160011b916000199060031b1c19161760048201555b60e08401518051906001600160401b038211612cf8576141ed60058401546136c4565b601f8111614446575b50602090601f83116001146143d057918061010094926006946000926143c5575b50508160011b916000199060031b1c19161760058201555b019301519283516001600160401b038111612cf85761424e82546136c4565b601f8111614388575b506020601f82116001146142fb57908060209493927f69add1952a6a6b9cb86f04d05f0cb605cbb469a50ae916139d34495a9991481f96976000926142f0575b50508160011b916000199060031b1c19161790555b6001600160401b0360405191168152a1600080808034335af16142cd613e42565b50156142d857600190565b604051630b288dc560e21b8152346004820152602490fd5b015190503880614297565b601f198216958360005260206000209660005b818110614370575096600192849260209796957f69add1952a6a6b9cb86f04d05f0cb605cbb469a50ae916139d34495a9991481f999a10614357575b505050811b0190556142ac565b015160001960f88460031b161c1916905538808061434a565b8383015189556001909801976020938401930161430e565b6143b590836000526020600020601f840160051c810191602085106143bb575b601f0160051c01906137a2565b38614257565b90915081906143a8565b015190503880614217565b906005840160005260206000209160005b601f198516811061442e575092610100949260019260069583601f19811610614415575b505050811b01600582015561422f565b015160001960f88460031b161c19169055388080614405565b919260206001819286850151815501940192016143e1565b61447590600585016000526020600020601f850160051c810191602086106143bb57601f0160051c01906137a2565b386141f6565b0151905038806141b2565b9250600484016000526020600020906000935b601f19841685106144dd576001945083601f198116106144c4575b505050811b0160048201556141ca565b015160001960f88460031b161c191690553880806144b4565b81810151835560209485019460019093019290910190614499565b61452790600486016000526020600020601f850160051c810191602086106143bb57601f0160051c01906137a2565b3861419b565b905038613fd3565b60448361454061522f565b90604051916326fb55dd60e01b835260048301526024820152fd5b5080613fc9565b613fc1565b9591949293969790976145997f0000000000000000000000000000000000000000000000000000000000000000615970565b6145a38287612e49565b926145ae8434612ee9565b94604051996101608b018b81106001600160401b03821117612cf85761ffff9a6001600160401b0391604052168b526001600160481b038c1660208c015289891660408c01528760608c015260808b015260018060a01b031660a08a015260c089015260e08801526101008701526101208601526101408501526060608060405161463881612d45565b60008152600060208201526000604082015260008382015201526001600160481b036040519561466787612d45565b16855260018060a01b037f00000000000000000000000000000000000000000000000000000000000000001660208601526040850152166060830152604051918260208101106001600160401b03602085011117612cf85761ffff90602084016040526000845260808101938452600060606001600160401b038551169261474d60018060a01b0360a0880151169760405196879485946315cfa3cb60e11b8652602060048701526001600160481b038151166024870152602081015160448701526040810151606487015201511660848401525160a060a484015260c4830190612cc0565b038173__$93083e246e55d56d98f3df2872cd16bfd0$__5af480156105a1576147b6946000938492614b49575b506040519261478884612d2a565b835260208301526040820152604051809481926311692f3760e31b835260206004840152602483019061332a565b038173__$93083e246e55d56d98f3df2872cd16bfd0$__5af49182156105a157600092614b24575b5081516020830120610120820151602061ffff6040850151169182600052600080516020615c268339815191528252604060002054906148216080870151614b84565b6101008701516040516312a12adb60e01b815260048101969096526024860193909352604485018690526001600160a01b0316606485015260a060848501528391829081906148749060a4830190612cc0565b03917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03165af180156105a157614b05575b5060608201517f75eb8927cc7c4810b30fa2e8011fce37da6da7d18eb82c642c367ae4445c362560a06080850151936148ec6020870151612bdf614d87565b9061012087015161ffff6040890151166001600160401b03895116916040519485526020850152604084015260608301526080820152a361ffff604082015116600052600080516020615c26833981519152602052600160406000200154916001600160801b038360081c1615614ae5576040516020810193600160f81b85526001600160801b03199060781b166021820152600060318201526021815261499381612d2a565b809360e0840151908151614a9c575b50505061014082015160408301516060840151608085015161ffff909216926001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016926149f590614b84565b9360c087015197843b156105ad57600096614a6e91614a5f614a4c6040519c8d9a8b998a9863c513d43760e01b8a5260048a0152602489015260018060a01b0316604488015260c0606488015260c4870190612cc0565b6003199384878303016084880152612cc0565b918483030160a4850152612cc0565b03925af19182156105a1576001600160401b0392614a8d575b50511690565b614a9690612ce5565b38614a87565b614abc93955091602091614adc9360405195869351809286860190612c9d565b8201614ad082518093868085019101612c9d565b01038084520182612d7b565b913880806149a2565b602461ffff6040840151166040519063d028893560e01b82526004820152fd5b614b1d9060203d602011612883576128748183612d7b565b50386148ad565b614b429192503d806000833e614b3a8183612d7b565b810190614bb0565b90386147de565b614b5e9192503d8086833e614b3a8183612d7b565b903861477a565b908160209103126105ad57516001600160401b03811681036105ad5790565b8060a01c614b98576001600160a01b031690565b6024906040519063033b960d60e41b82526004820152fd5b906020828203126105ad5781516001600160401b0381116105ad57612e0992016132e8565b9291614c0490612bd77f0000000000000000000000000000000000000000000000000000000000000000615970565b906000937f504e6efe18ab9eed10dc6501a417f5b12a2f7f2b1593aed9b89f9bce3cf29a918580a27f0000000000000000000000000000000000000000000000000000000000000000936002851015614d735784614ccb575060405163a9059cbb60e01b60208201526001600160a01b0391909116602482015260448082019290925290815290915061318890614c9c606482612d7b565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316613d63565b919360018103614d5757507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690813b1561063b576040516340c10f1960e01b81526001600160a01b03919091166004820152602481019490945291929181908390604490829084905af19081156132bd5750614d4e575b50565b61318890612ce5565b6040516366001a8960e01b815260ff9091166004820152602490fd5b634e487b7160e01b81526021600452602490fd5b600080604051602081019063313ce56760e01b825260048152614da981612d60565b51907f00000000000000000000000000000000000000000000000000000000000000005afa614dd6613e42565b9015614df5576020818051810103126105ad576020612e099101612f20565b604051631222cd8360e01b8152600490fd5b6040516370a0823160e01b602082019081526001600160a01b039093166024808301919091528152600092839291614e3e81612d2a565b51915afa614e4a613e42565b9015614df5576020818051810103126105ad576020015190565b600080516020615c668339815191525460005b818110614e82575050565b80614ea161ffff614e9460019461301b565b90549060031b1c166131b5565b01614e77565b307f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031614614ed957565b604051633c64f99360e21b8152600490fd5b15614ef257565b634e487b7160e01b600052600160045260246000fd5b600080516020615d2683398151915254336001600160a01b039182161415919082614f4e575b5050614f3657565b60405163e2a08e5d60e01b8152336004820152602490fd5b1633141590503880614f2e565b600080516020615d46833981519152805491614f75614d87565b916001600160481b0393848116916001600160401b0395868360081c169384158061517c575b156150525750856150459460ff6040989585615036957f7e3b0fc388be9d36273f66210aed83be975df3a9adfffa4c734033f498f362cd9c9a9754600160481b600160901b038960481b1690600160481b600160901b0319161782555b815479ffffffffffffffff000000000000000000ffffffffffffffffff1916908816174260901b67ffffffffffffffff60901b161790551690615a63565b9360ff82169160081c16615a63565b82519182526020820152a1565b61505d612bd2615187565b8660009261506b8282615998565b156151255761507b9293506159ef565b6150858183615998565b1561511c57615093916159ef565b61509d8682615998565b6150fa57956150459460ff82957f7e3b0fc388be9d36273f66210aed83be975df3a9adfffa4c734033f498f362cd9a989561503695600160481b600160901b0360409c60481b16600160481b600160901b03198416178255614ff8565b604051631e74e8fb60e31b815290821660048201529085166024820152604490fd5b5060ff16615093565b61512e916159ef565b9061513982826159ba565b89808360081c169160081c160191898311615168575060ff68ffffffffffffffff0091169160081b1617615093565b634e487b7160e01b81526011600452602490fd5b5060ff841615614f9b565b6040519061519482612d2a565b8160406001600160401b03600080516020615d46833981519152546001600160481b0380821685528160481c16602085015260901c16910152565b906040516151dc81612d2a565b60406001600160401b038294546001600160481b0380821685528160481c16602085015260901c16910152565b90600160481b600160901b0382549160481b1690600160481b600160901b031916179055565b6152376132c9565b50612e09612bd7612bd2615187565b9061ffff16906000828152600080516020615cc68339815191526020526040812091825491615273614d87565b926001600160481b0394858216956001600160401b0396878460081c1694851580615426575b15615342575050856153359460ff6040989561532e86615036966152e08c7f739ed886fd81a3ddc9f4b327ab69152e513cd45b26fda0c73660eaca8e1193019f9d9a615209565b815467ffffffffffffffff60901b19918a169190911679ffffffffffffffff000000000000000000ffffffffffffffffff1990911617428c1660901b67ffffffffffffffff60901b16179055565b1690615a63565b82519182526020820152a2565b61534e612bd2856151cf565b908761535a8185615998565b156153e15761536a9192936159ef565b906153758284615998565b1590506153d857615385916159ef565b61538f8682615998565b6150fa57956153359460ff829561532e86615036966153d360409d7f739ed886fd81a3ddc9f4b327ab69152e513cd45b26fda0c73660eaca8e1193019f9d9a615209565b6152e0565b5060ff16615385565b926153ec91936159ef565b906153f782826159ba565b89808360081c169160081c160191898311615168575060ff68ffffffffffffffff0091169160081b1617615385565b5060ff851615615299565b6154396132c9565b506000527f4e8909a01183a67951f5a6147d6e76ed02ea890c72afea01a9edee91edc609b860205260406000206040519061547382612d2a565b80546001600160481b038116835260481c6001600160401b03166020830152600101546001600160a01b0316604082015290565b81156154b1570490565b634e487b7160e01b600052601260045260246000fd5b6001600160401b0390817f00000000000000000000000000000000000000000000000000000000000000001691821561555c57615549828260ff93604068ffffffffffffffff009601511642038161552d602085019889519383875160081c16026154a7565b9160081c1601915160081c168082106000146155555750615574565b9251169160081b161790565b9050615574565b506020015160ff1668ffffffffffffffff0017919050565b6001600160401b0390818111615588571690565b60405162461bcd60e51b815260206004820152602660248201527f53616665436173743a2076616c756520646f65736e27742066697420696e203660448201526534206269747360d01b6064820152608490fd5b6001600160401b037f00000000000000000000000000000000000000000000000000000000000000001615614d4b576156136132c9565b5061561f612bd2615187565b600160481b600160901b03615645600080516020615d46833981519152938454936159ef565b60481b16906001600160401b0360901b4260901b1690600160481b600160d01b03191617179055565b6001600160401b0390817f00000000000000000000000000000000000000000000000000000000000000001615615790576156a76132c9565b506156b3612bd2615187565b90600160481b600160901b03600080516020615d4683398151915293845493816001600160401b0360901b4260901b16946156ee81846159ba565b60081c16828260081c160182811160001461577b575068ffffffffffffffff0060ff61571984615574565b92169160081b1617906001600160481b0385169061573782846159ba565b80856001600160401b0360901b1988161760081c16908360081c161060001461577457505b60481b1691600160481b600160d01b03191617179055565b905061575c565b60ff61571968ffffffffffffffff0092615574565b5050565b906001600160401b0390817f0000000000000000000000000000000000000000000000000000000000000000161561344e576131889261ffff615841926157d96132c9565b501680600052600080516020615cc683398151915280602052615802612bd260406000206151cf565b60009283526020919091526040909120805467ffffffffffffffff60901b19164290951660901b67ffffffffffffffff60901b169490941784556159ef565b90615209565b6001600160401b03807f0000000000000000000000000000000000000000000000000000000000000000161561344e5761ffff613188936158866132c9565b5016600090808252600080516020615cc6833981519152806020526158b0612bd2604085206151cf565b91835260205260408220805467ffffffffffffffff60901b191642851660901b67ffffffffffffffff60901b161781559383906158ed81846159ba565b60081c16838260081c160183811160001461595b575068ffffffffffffffff0060ff61591885615574565b92169160081b1617918084546001600160481b0381169361593985876159ba565b5060081c16908360081c1610600014615953575090615209565b905090615209565b60ff61591868ffffffffffffffff0092615574565b46810361597a5750565b604490604051906377d879fb60e01b82526004820152466024820152fd5b906159a381836159ba565b6001600160401b03809160081c169160081c161190565b60ff91821691168181036159cc575050565b604051635ce6db6160e11b815260ff918216600482015291166024820152604490fd5b6159f982826159ba565b6001600160401b03809260081c16828260081c1603918211612ef65760ff68ffffffffffffffff0091169160081b161790565b60ff811660081015612e095750600890565b9060ff8091169116039060ff8211612ef657565b60ff16604d8111612ef657600a0a90565b919060ff821660ff8216818114615ab7571115615a9657615a8b612e099392615a9092615a3e565b615a52565b906154a7565b615a8b90615aa392615a3e565b90818102918183041490151715612ef65790565b5050505090565b615af2613f4c60ff9268ffffffffffffffff009495615adc87615a2c565b908581168683161015615afd5750958691615a63565b92169160081b161790565b9050958691615a63565b60ff7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a005460401c1615615b3657565b604051631afcd79f60e31b8152600490fd5b6001600160a01b03908116908115615ba357600080516020615c8683398151915280546001600160a01b031981168417909155167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0600080a3565b604051631e4fbdf760e01b815260006004820152602490fd5b600080516020615c86833981519152546001600160a01b03163303615bdd57565b60405163118cdaa760e01b8152336004820152602490fd5b600080516020615d068339815191526002815414615c135760029055565b604051633ee5aeb560e01b8152600490fdfeebcc9f646b0f459ff8f387587d536b0af3484cf442e1577400f322334e7d1ef047028352a8b3feae1a85fba43bc13f990568bb1637dce33d3dbfd791a0808b7f3b7aba7dd7414fe6f86067371f2a5b07a6b0344c1b86c5f36adb59df9895cd629016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c19930064bacf405c5d7f563d3ba5252584a52c37e4fee380fd825b10666c27b8258022efb21dcaedea63b55c44882f329622e13a8d0f5b947b3a372826208a9003da15852fa0677fef8612c6c15b518c9fa56761e9ed15cfd5c6e5399e5467985ac7ed9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00bfa91572ce1e5fe8776a160d3b1f862e83f5ee2c080a7423b4761602a3ad12497c25289a27ec8c9be54d4a154cf80490d69bda989cdb8328232e08fea9220420a26469706673582212208433ce73412cdd47522f0b53ef4591451befbcc3e4f6c57195bc7e5ed139c63d64736f6c63430008130033"; + +type NttManagerConstructorParams = + | [linkLibraryAddresses: NttManagerLibraryAddresses, signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: NttManagerConstructorParams +): xs is ConstructorParameters => { + return ( + typeof xs[0] === "string" || + (Array.isArray as (arg: any) => arg is readonly any[])(xs[0]) || + "_isInterface" in xs[0] + ); +}; + +export class NttManager__factory extends ContractFactory { + constructor(...args: NttManagerConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + const [linkLibraryAddresses, signer] = args; + super( + _abi, + NttManager__factory.linkBytecode(linkLibraryAddresses), + signer + ); + } + } + + static linkBytecode( + linkLibraryAddresses: NttManagerLibraryAddresses + ): string { + let linkedBytecode = _bytecode; + + linkedBytecode = linkedBytecode.replace( + new RegExp("__\\$93083e246e55d56d98f3df2872cd16bfd0\\$__", "g"), + linkLibraryAddresses[ + "src/libraries/TransceiverStructs.sol:TransceiverStructs" + ] + .replace(/^0x/, "") + .toLowerCase() + ); + + return linkedBytecode; + } + + override getDeployTransaction( + _endpoint: AddressLike, + _executor: AddressLike, + _token: AddressLike, + _mode: BigNumberish, + _chainId: BigNumberish, + _rateLimitDuration: BigNumberish, + _skipRateLimiting: boolean, + overrides?: NonPayableOverrides & { from?: string } + ): Promise { + return super.getDeployTransaction( + _endpoint, + _executor, + _token, + _mode, + _chainId, + _rateLimitDuration, + _skipRateLimiting, + overrides || {} + ); + } + override deploy( + _endpoint: AddressLike, + _executor: AddressLike, + _token: AddressLike, + _mode: BigNumberish, + _chainId: BigNumberish, + _rateLimitDuration: BigNumberish, + _skipRateLimiting: boolean, + overrides?: NonPayableOverrides & { from?: string } + ) { + return super.deploy( + _endpoint, + _executor, + _token, + _mode, + _chainId, + _rateLimitDuration, + _skipRateLimiting, + overrides || {} + ) as Promise< + NttManager & { + deploymentTransaction(): ContractTransactionResponse; + } + >; + } + override connect(runner: ContractRunner | null): NttManager__factory { + return super.connect(runner) as NttManager__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): NttManagerInterface { + return new Interface(_abi) as NttManagerInterface; + } + static connect(address: string, runner?: ContractRunner | null): NttManager { + return new Contract(address, _abi, runner) as unknown as NttManager; + } +} + +export interface NttManagerLibraryAddresses { + ["src/libraries/TransceiverStructs.sol:TransceiverStructs"]: string; +} diff --git a/evm/ts/src/ethers-contracts/2_0_0/factories/index.ts b/evm/ts/src/ethers-contracts/2_0_0/factories/index.ts new file mode 100644 index 000000000..844e137ef --- /dev/null +++ b/evm/ts/src/ethers-contracts/2_0_0/factories/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { NttManager__factory } from "./NttManager__factory.js"; diff --git a/evm/ts/src/ethers-contracts/2_0_0/index.ts b/evm/ts/src/ethers-contracts/2_0_0/index.ts new file mode 100644 index 000000000..ad2af3ee6 --- /dev/null +++ b/evm/ts/src/ethers-contracts/2_0_0/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { NttManager } from "./NttManager.js"; +export * as factories from "./factories/index.js"; +export { NttManager__factory } from "./factories/NttManager__factory.js"; diff --git a/evm/ts/src/ethers-contracts/index.ts b/evm/ts/src/ethers-contracts/index.ts index 2e32dc983..d9d465421 100644 --- a/evm/ts/src/ethers-contracts/index.ts +++ b/evm/ts/src/ethers-contracts/index.ts @@ -1,6 +1,7 @@ import * as __0_1_0 from "./0_1_0/index.js"; import * as __1_0_0 from "./1_0_0/index.js"; import * as __1_1_0 from "./1_1_0/index.js"; +import * as __2_0_0 from "./2_0_0/index.js"; const _0_1_0 = { NttManager: { @@ -29,4 +30,10 @@ const _1_1_0 = { }, }; -export { _0_1_0, _1_0_0, _1_1_0 }; +const _2_0_0 = { + NttManager: { + connect: __2_0_0.NttManager__factory.connect, + }, +}; + +export { _0_1_0, _1_0_0, _1_1_0, _2_0_0 }; diff --git a/evm/ts/src/executor/BinaryReader.ts b/evm/ts/src/executor/BinaryReader.ts new file mode 100644 index 000000000..ba387fb86 --- /dev/null +++ b/evm/ts/src/executor/BinaryReader.ts @@ -0,0 +1,106 @@ +import { Buffer } from "buffer"; + +export function isValidHexString(s: string): boolean { + return /^(0x)?[0-9a-fA-F]+$/.test(s); +} + +export function hexToBuffer(s: string): Buffer { + if (!isValidHexString(s)) { + throw new Error(`${s} is not hex`); + } + if (s.startsWith("0x")) { + s = s.slice(2); + } + s.padStart(s.length + (s.length % 2), "0"); + return Buffer.from(s, "hex"); +} + +export function hexToUint8Array(s: string): Uint8Array { + return new Uint8Array(hexToBuffer(s)); +} + +export function uint8ArrayToHex(b: Uint8Array): `0x${string}` { + return `0x${Buffer.from(b).toString("hex")}`; +} + +// BinaryReader provides the inverse of BinaryWriter +// Numbers are encoded as big endian +export class BinaryReader { + private _buffer: Buffer; + private _offset: number; + + constructor( + arrayBufferOrString: + | WithImplicitCoercion + | string + ) { + if (typeof arrayBufferOrString === "string") { + this._buffer = hexToBuffer(arrayBufferOrString); + } else { + this._buffer = Buffer.from(arrayBufferOrString); + } + this._offset = 0; + } + + length(): number { + return this._buffer.length; + } + + offset(): number { + return this._offset; + } + + readUint8(): number { + const tmp = this._buffer.readUint8(this._offset); + this._offset += 1; + return tmp; + } + + readUint16(): number { + const tmp = this._buffer.readUint16BE(this._offset); + this._offset += 2; + return tmp; + } + + readUint32(): number { + const tmp = this._buffer.readUint32BE(this._offset); + this._offset += 4; + return tmp; + } + + readUint64(): bigint { + const tmp = this._buffer.readBigUInt64BE(this._offset); + this._offset += 8; + return tmp; + } + + readUint128(): bigint { + const tmp = this._buffer.subarray(this._offset, this._offset + 16); + this._offset += 16; + return BigInt(`0x${tmp.toString("hex") || "0"}`); + } + + readUint256(): bigint { + const tmp = this._buffer.subarray(this._offset, this._offset + 32); + this._offset += 32; + return BigInt(`0x${tmp.toString("hex") || "0"}`); + } + + readUint8Array(length: number): Uint8Array { + const tmp = this._buffer.subarray(this._offset, this._offset + length); + this._offset += length; + return new Uint8Array(tmp); + } + + readHex(length: number): `0x${string}` { + return uint8ArrayToHex(this.readUint8Array(length)); + } + + readString(length: number): string { + const tmp = this._buffer + .subarray(this._offset, this._offset + length) + .toString(); + this._offset += length; + return tmp; + } +} diff --git a/evm/ts/src/executor/BinaryWriter.ts b/evm/ts/src/executor/BinaryWriter.ts new file mode 100644 index 000000000..61b05c497 --- /dev/null +++ b/evm/ts/src/executor/BinaryWriter.ts @@ -0,0 +1,91 @@ +import { Buffer } from "buffer"; +import { hexToUint8Array, uint8ArrayToHex } from "./BinaryReader.js"; + +export const MAX_U64 = 18446744073709551615n; +export const MAX_U128 = 340282366920938463463374607431768211455n; +export const MAX_U256 = + 115792089237316195423570985008687907853269984665640564039457584007913129639935n; + +// BinaryWriter appends data to the end of a buffer, resizing the buffer as needed +// Numbers are encoded as big endian +export class BinaryWriter { + private _buffer: Buffer; + private _offset: number; + + constructor(initialSize: number = 1024) { + if (initialSize < 0) throw new Error("Initial size must be non-negative"); + this._buffer = Buffer.alloc(initialSize); + this._offset = 0; + } + + // Ensure the buffer has the capacity to write `size` bytes, otherwise allocate more memory + _ensure(size: number) { + const remaining = this._buffer.length - this._offset; + if (remaining < size) { + const oldBuffer = this._buffer; + const newSize = this._buffer.length * 2 + size; + this._buffer = Buffer.alloc(newSize); + oldBuffer.copy(new Uint8Array(this._buffer)); + } + } + + writeUint8(value: number) { + if (value < 0 || value > 255) throw new Error("Invalid value"); + this._ensure(1); + this._buffer.writeUint8(value, this._offset); + this._offset += 1; + return this; + } + + writeUint16(value: number) { + if (value < 0 || value > 65535) throw new Error("Invalid value"); + this._ensure(2); + this._offset = this._buffer.writeUint16BE(value, this._offset); + return this; + } + + writeUint32(value: number) { + if (value < 0 || value > 4294967295) throw new Error("Invalid value"); + this._ensure(4); + this._offset = this._buffer.writeUint32BE(value, this._offset); + return this; + } + + writeUint64(value: bigint) { + if (value < 0n || value > MAX_U64) throw new Error("Invalid value"); + this._ensure(8); + this._offset = this._buffer.writeBigUInt64BE(value, this._offset); + return this; + } + + writeUint128(value: bigint) { + if (value < 0n || value > MAX_U128) throw new Error("Invalid value"); + return this.writeHex(value.toString(16).padStart(16 * 2, "0")); + } + + writeUint256(value: bigint) { + if (value < 0n || value > MAX_U256) throw new Error("Invalid value"); + return this.writeHex(value.toString(16).padStart(32 * 2, "0")); + } + + writeUint8Array(value: Uint8Array) { + this._ensure(value.length); + this._buffer.set(value, this._offset); + this._offset += value.length; + return this; + } + + writeHex(value: string) { + return this.writeUint8Array(hexToUint8Array(value)); + } + + data(): Uint8Array { + const copy = new Uint8Array(this._offset); + copy.set(this._buffer.subarray(0, this._offset)); + return copy; + } + + toHex(): `0x${string}` { + return uint8ArrayToHex(this.data()); + } +} diff --git a/evm/ts/src/executor/fetch.ts b/evm/ts/src/executor/fetch.ts new file mode 100644 index 000000000..b0e73d8fe --- /dev/null +++ b/evm/ts/src/executor/fetch.ts @@ -0,0 +1,23 @@ +// TODO: these functions belong in an sdk for the executor (where the types can be shared) +import axios from "axios"; +import { Chain, chainToChainId } from "@wormhole-foundation/sdk"; +export async function fetchQuote( + srcChain: Chain, + dstChain: Chain +): Promise<`0x${string}`> { + const ret = await axios.get( + `http://executor:3000/v0/quote/${chainToChainId(srcChain)}/${chainToChainId( + dstChain + )}` + ); + return ret.data.signedQuote; +} +export async function fetchEstimate( + quote: `0x${string}`, + relayInstructions: `0x${string}` +): Promise { + const ret = await axios.get( + `http://executor:3000/v0/estimate/${quote}/${relayInstructions}/` + ); + return BigInt(ret.data.estimate); +} diff --git a/evm/ts/src/executor/relayInstructions.ts b/evm/ts/src/executor/relayInstructions.ts new file mode 100644 index 000000000..a42fdde60 --- /dev/null +++ b/evm/ts/src/executor/relayInstructions.ts @@ -0,0 +1,92 @@ +import { BinaryReader } from "./BinaryReader.js"; +import { BinaryWriter } from "./BinaryWriter.js"; + +const RECV_INST_TYPE_GAS = 1; +const RECV_INST_TYPE_DROP_OFF = 2; + +interface RelayInstruction { + type: string; +} + +interface GasInstruction extends RelayInstruction { + type: "GasInstruction"; + gasLimit: bigint; + msgValue: bigint; +} + +interface GasDropOffInstruction extends RelayInstruction { + type: "GasDropOffInstruction"; + dropOff: bigint; + recipient: string; +} + +type RelayInstructions = (GasInstruction | GasDropOffInstruction)[]; + +export function decodeRelayInstructions( + relayInstructionsBytes: + | WithImplicitCoercion + | string +): RelayInstructions { + const relayInstructions: RelayInstructions = []; + const reader = new BinaryReader(relayInstructionsBytes); + while (reader.offset() < reader.length()) { + const type = reader.readUint8(); + if (type === RECV_INST_TYPE_GAS) { + relayInstructions.push({ + type: "GasInstruction", + gasLimit: reader.readUint128(), + msgValue: reader.readUint128(), + }); + } else if (type === RECV_INST_TYPE_DROP_OFF) { + relayInstructions.push({ + type: "GasDropOffInstruction", + dropOff: reader.readUint128(), + recipient: reader.readHex(32), + }); + } else { + throw new Error(`unsupported relay instruction type: ${type}`); + } + } + if (reader.offset() > reader.length()) { + throw new Error(`unable to decode relay instructions`); + } + return relayInstructions; +} + +export function encodeRelayInstructions( + relayInstructions: RelayInstructions +): `0x${string}` { + const writer = new BinaryWriter(); + for (const relayInstruction of relayInstructions) { + if (relayInstruction.type === "GasInstruction") { + writer + .writeUint8(RECV_INST_TYPE_GAS) + .writeUint128(relayInstruction.gasLimit) + .writeUint128(relayInstruction.msgValue); + } else if (relayInstruction.type === "GasDropOffInstruction") { + // TODO: enforce length on recipient + writer + .writeUint8(RECV_INST_TYPE_DROP_OFF) + .writeUint128(relayInstruction.dropOff) + .writeHex(relayInstruction.recipient); + } + } + return writer.toHex(); +} + +export function totalGasLimitAndMsgValue( + relayInstructions: RelayInstructions +): { + gasLimit: bigint; + msgValue: bigint; +} { + let gasLimit = 0n; + let msgValue = 0n; + for (const relayInstruction of relayInstructions) { + if (relayInstruction.type === "GasInstruction") { + gasLimit += relayInstruction.gasLimit; + msgValue += relayInstruction.msgValue; + } + } + return { gasLimit, msgValue }; +} diff --git a/evm/ts/src/ntt.ts b/evm/ts/src/ntt.ts index 07b4cb8cf..68d6d89ca 100644 --- a/evm/ts/src/ntt.ts +++ b/evm/ts/src/ntt.ts @@ -42,6 +42,9 @@ import { NttTransceiverBindings, loadAbiVersion, } from "./bindings.js"; +import { BinaryWriter } from "./executor/BinaryWriter.js"; +import { fetchEstimate, fetchQuote } from "./executor/fetch.js"; +import { encodeRelayInstructions } from "./executor/relayInstructions.js"; export class EvmNttWormholeTranceiver implements @@ -194,7 +197,7 @@ export class EvmNtt readonly chain: C, readonly provider: Provider, readonly contracts: Contracts & { ntt?: Ntt.Contracts }, - readonly version: string = "1.0.0" + readonly version: string = "2.0.0" ) { if (!contracts.ntt) throw new Error("No Ntt Contracts provided"); @@ -214,32 +217,6 @@ export class EvmNtt ); this.xcvrs = []; - if ( - "wormhole" in contracts.ntt.transceiver && - contracts.ntt.transceiver["wormhole"] - ) { - const transceiverTypes = [ - "wormhole", // wormhole xcvr should be ix 0 - ...Object.keys(contracts.ntt.transceiver).filter((transceiverType) => { - transceiverType !== "wormhole"; - }), - ]; - transceiverTypes.map((transceiverType) => { - // we currently only support wormhole transceivers - if (transceiverType !== "wormhole") { - throw new Error(`Unsupported transceiver type: ${transceiverType}`); - } - - // Enable more Transceivers here - this.xcvrs.push( - new EvmNttWormholeTranceiver( - this, - contracts.ntt!.transceiver[transceiverType]!, - abiBindings! - ) - ); - }); - } } async getTransceiver(ix: number): Promise | null> { @@ -290,8 +267,8 @@ export class EvmNtt yield this.createUnsignedTx(tx, "Ntt.setPauser"); } - async getThreshold(): Promise { - return Number(await this.manager.getThreshold()); + async getThreshold(chainId: number): Promise { + return Number(await this.manager.getThreshold(chainId)); } async isRelayingAvailable(destination: Chain): Promise { @@ -309,13 +286,15 @@ export class EvmNtt } async getIsExecuted(attestation: Ntt.Attestation): Promise { - const payload = - attestation.payloadName === "WormholeTransfer" - ? attestation.payload - : attestation.payload["payload"]; - const isExecuted = await this.manager.isMessageExecuted( - Ntt.messageDigest(attestation.emitterChain, payload["nttManagerPayload"]) - ); + // const payload = + // attestation.payloadName === "WormholeTransfer" + // ? attestation.payload + // : attestation.payload["payload"]; + const isExecuted = false; + // TODO: err... fix this + // await this.manager.isMessageExecuted( + // Ntt.messageDigest(attestation.emitterChain, payload["nttManagerPayload"]) + // ); if (!isExecuted) return false; // Also check that the transfer is not queued for it to be considered complete return !(await this.getIsTransferInboundQueued(attestation)); @@ -337,13 +316,15 @@ export class EvmNtt } getIsApproved(attestation: Ntt.Attestation): Promise { - const payload = - attestation.payloadName === "WormholeTransfer" - ? attestation.payload - : attestation.payload["payload"]; - return this.manager.isMessageApproved( - Ntt.messageDigest(attestation.emitterChain, payload["nttManagerPayload"]) - ); + // TODO: err... fix this + return Promise.resolve(true); + // const payload = + // attestation.payloadName === "WormholeTransfer" + // ? attestation.payload + // : attestation.payload["payload"]; + // return this.manager.isMessageApproved( + // Ntt.messageDigest(attestation.emitterChain, payload["nttManagerPayload"]) + // ); } async getTokenDecimals(): Promise { @@ -365,6 +346,7 @@ export class EvmNtt return { address: { chain: chain, address: toUniversal(chain, peerAddress) }, tokenDecimals: Number(peer.tokenDecimals), + gasLimit: peer.gasLimit, inboundLimit: await this.getInboundLimit(chain), }; } @@ -426,7 +408,7 @@ export class EvmNtt dstChain: Chain, options: Ntt.TransferOptions ): Promise { - const [, totalPrice] = await this.manager.quoteDeliveryPrice( + const totalPrice = await this.manager.quoteDeliveryPrice( toChainId(dstChain), Ntt.encodeTransceiverInstructions(this.encodeOptions(options)) ); @@ -436,12 +418,14 @@ export class EvmNtt async *setPeer( peer: ChainAddress, tokenDecimals: number, + gasLimit: bigint, inboundLimit: bigint ) { const tx = await this.manager.setPeer.populateTransaction( toChainId(peer.chain), universalAddress(peer), tokenDecimals, + gasLimit, inboundLimit ); yield this.createUnsignedTx(tx, "Ntt.setPeer"); @@ -466,11 +450,48 @@ export class EvmNtt ): AsyncGenerator> { const senderAddress = new EvmAddress(sender).toString(); + const peer = await this.getPeer(destination.chain); + if (!peer) { + throw new Error(`null peer for destination chain ${destination.chain}`); + } + const quote = await fetchQuote(this.chain, destination.chain); + const relayInstruction = encodeRelayInstructions([ + { type: "GasInstruction", gasLimit: peer.gasLimit, msgValue: 0n }, + ]); + const executorEstimate = await fetchEstimate(quote, relayInstruction); + + // assemble the transceiver instructions + // like https://github.com/wormholelabs-xyz/example-messaging-adapter-wormhole-guardians/blob/7deb17c52d95b252435740a1047902a857b5fea8/evm/src/WormholeGuardiansAdapterWithExecutor.sol#L132-L152 + // and https://github.com/wormholelabs-xyz/example-messaging-endpoint/blob/0f853ea0335937d611217f5048d677a4f46249fd/evm/src/libraries/AdapterInstructions.sol#L37-L66 + const wgaGasLimit = 1000000n; // determine some amount of gas based on destination chain + const wgaRelayInstruction = encodeRelayInstructions([ + { type: "GasInstruction", gasLimit: wgaGasLimit, msgValue: 0n }, + ]); + const wgaExecutorEstimate = await fetchEstimate(quote, wgaRelayInstruction); + const transceiversInstruction = new BinaryWriter() + .writeUint8(1) // version + .writeUint256(wgaExecutorEstimate) + .writeUint16((quote.length - 2) / 2) + .writeHex(quote) + .writeUint16((wgaRelayInstruction.length - 2) / 2) + .writeHex(wgaRelayInstruction) + .data(); + const transceiversInstructions = new BinaryWriter() + .writeUint8(1) // instructionsLength + .writeUint8(0) // instruction.index + .writeUint16(transceiversInstruction.length) + .writeUint8Array(transceiversInstruction) + .toHex(); + // Note: these flags are indexed by transceiver index - const totalPrice = await this.quoteDeliveryPrice( - destination.chain, - options - ); + const totalPrice = + executorEstimate + + (await this.manager.quoteDeliveryPrice( + toChainId(destination.chain), + transceiversInstructions + )); + // TODO: make quoteDeliveryPrice work again + // (await this.quoteDeliveryPrice(destination.chain, options)); //TODO check for ERC-2612 (permit) support on token? const tokenContract = EvmPlatform.getTokenImplementation( @@ -492,14 +513,18 @@ export class EvmNtt const receiver = universalAddress(destination); const txReq = await this.manager - .getFunction("transfer(uint256,uint16,bytes32,bytes32,bool,bytes)") + .getFunction( + "transfer(uint256,uint16,bytes32,bytes32,bool,bytes,bytes,bytes)" + ) .populateTransaction( amount, toChainId(destination.chain), receiver, receiver, options.queue, - Ntt.encodeTransceiverInstructions(this.encodeOptions(options)), + quote, + "0x", // TODO: optionally encode gas dropoff relay instruction + transceiversInstructions, { value: totalPrice } ); @@ -615,7 +640,8 @@ export class EvmNtt manager: this.managerAddress, token: await this.manager.token(), transceiver: { - wormhole: (await this.manager.getTransceivers())[0]!, // TODO: make this more generic + // TODO: idk how this should work now + // wormhole: (await this.manager.getTransceivers())[0]!, // TODO: make this more generic }, }; diff --git a/package-lock.json b/package-lock.json index 780760dcb..8093460a1 100644 --- a/package-lock.json +++ b/package-lock.json @@ -23,6 +23,7 @@ "@types/node": "^20.12.2", "@wormhole-foundation/sdk": "^1.0.0", "@wormhole-foundation/wormchain-sdk": "^0.0.1", + "axios": "^1.7.9", "ethers": "^6.5.1", "ts-jest": "^29.1.2", "tsx": "^4.7.2", @@ -5970,9 +5971,9 @@ "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" }, "node_modules/axios": { - "version": "1.7.7", - "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz", - "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==", + "version": "1.7.9", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz", + "integrity": "sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==", "license": "MIT", "dependencies": { "follow-redirects": "^1.15.6", diff --git a/package.json b/package.json index 2f2293458..d3a88e7c2 100644 --- a/package.json +++ b/package.json @@ -23,6 +23,7 @@ "@types/node": "^20.12.2", "@wormhole-foundation/sdk": "^1.0.0", "@wormhole-foundation/wormchain-sdk": "^0.0.1", + "axios": "^1.7.9", "ethers": "^6.5.1", "ts-jest": "^29.1.2", "tsx": "^4.7.2", diff --git a/sdk/Dockerfile b/sdk/Dockerfile index acfbbd44a..88ab8df85 100644 --- a/sdk/Dockerfile +++ b/sdk/Dockerfile @@ -15,10 +15,11 @@ COPY --from=ntt-evm-contract . evm/out RUN rm -rf evm/out/ts -COPY . ./ +COPY package.json package-lock.json ./ RUN --mount=type=cache,uid=1000,gid=1000,target=/home/node/.npm \ npm ci +COPY . ./ RUN npm run build RUN npm run generate:test diff --git a/sdk/__tests__/index.test.ts b/sdk/__tests__/index.test.ts index e510b7e18..31a6ff622 100644 --- a/sdk/__tests__/index.test.ts +++ b/sdk/__tests__/index.test.ts @@ -66,17 +66,17 @@ describe("Hub and Spoke Tests", function () { test("Test Solana and Ethereum Hubs", async () => { await Promise.all([ + // testHub( + // "Solana", + // "Ethereum", + // "Bsc", + // makeGetNativeSigner(ETH_PRIVATE_KEY, SOL_PRIVATE_KEY), + // ACCT_MNEMONIC + // ), testHub( - "Solana", "Ethereum", "Bsc", - makeGetNativeSigner(ETH_PRIVATE_KEY, SOL_PRIVATE_KEY), - ACCT_MNEMONIC - ), - testHub( - "Ethereum", - "Bsc", - "Solana", + // "Solana", makeGetNativeSigner(ETH_PRIVATE_KEY_2, SOL_PRIVATE_KEY_2), ACCT_MNEMONIC_2 ), diff --git a/sdk/__tests__/utils.ts b/sdk/__tests__/utils.ts index 990c0675a..2ea85e9d9 100644 --- a/sdk/__tests__/utils.ts +++ b/sdk/__tests__/utils.ts @@ -5,13 +5,16 @@ import { Chain, ChainAddress, ChainContext, + ChainId, NativeSigner, Platform, Signer, + TransactionId, VAA, Wormhole, WormholeMessageId, amount, + chainToChainId, chainToPlatform, encoding, keccak256, @@ -31,7 +34,6 @@ import { IWormholeRelayer__factory } from "../../evm/ts/ethers-ci-contracts/fact import { NttManager__factory } from "../../evm/ts/ethers-ci-contracts/factories/NttManager__factory.js"; import { TransceiverStructs__factory } from "../../evm/ts/ethers-ci-contracts/factories/TransceiverStructs__factory.js"; import { TrimmedAmountLib__factory } from "../../evm/ts/ethers-ci-contracts/factories/TrimmedAmount.sol/TrimmedAmountLib__factory.js"; -import { WormholeTransceiver__factory } from "../../evm/ts/ethers-ci-contracts/factories/WormholeTransceiver__factory.js"; import "../../evm/ts/src/index.js"; import "../../solana/ts/sdk/index.js"; @@ -39,11 +41,24 @@ import { NTT } from "../../solana/ts/lib/index.js"; import { SolanaNtt } from "../../solana/ts/sdk/index.js"; import { Ntt } from "../definitions/src/index.js"; import { submitAccountantVAAs } from "./accountant.js"; +import axios from "axios"; // Note: Currently, in order for this to run, the evm bindings with extra contracts must be build // To do that, at the root, run `npm run generate:test` export const NETWORK: "Devnet" = "Devnet"; +export const ENDPOINTS: { [chainId in ChainId]?: `0x${string}` } = { + 2: "0xF9f67913ba058BD29E699BfcD0eb0ec878555226", + 4: "0x86ee2Ad4bca65764928680812A6C5315eDA9EEfd", +}; +export const EXECUTORS: { [chainId in ChainId]?: `0x${string}` } = { + 2: "0x0a65677098872f870224F6E9533734F4a4B0eBAB", + 4: "0xB67841A38bF16EB9999dC7B6015746506e20F0aA", +}; +export const WHG_ADAPTERS: { [chainId in ChainId]?: `0x${string}` } = { + 2: "0x47A17F7E84Fb16c752352325F854A5358b4461d0", + 4: "0x9683b5Cb8F274510782183CB20E76c3F7C1c884b", +}; type NativeSdkSigner

= P extends "Evm" ? ethers.Wallet @@ -116,24 +131,24 @@ export async function link(chainInfos: Ctx[], accountantPrivateKey: string) { console.log("========================"); // first submit hub init to accountant - const hub = chainInfos[0]!; - const hubChain = hub.context.chain; - - const msgId: WormholeMessageId = { - chain: hubChain, - emitter: Wormhole.chainAddress( - hubChain, - hub.contracts!.transceiver["wormhole"]! - ).address.toUniversalAddress(), - sequence: 0n, - }; + // const hub = chainInfos[0]!; + // const hubChain = hub.context.chain; + + // const msgId: WormholeMessageId = { + // chain: hubChain, + // emitter: Wormhole.chainAddress( + // hubChain, + // hub.contracts!.transceiver["wormhole"]! + // ).address.toUniversalAddress(), + // sequence: 0n, + // }; - const vaa = await wh.getVaa(msgId, "Ntt:TransceiverInfo"); - const vaas: Uint8Array[] = [serialize(vaa!)]; + // const vaa = await wh.getVaa(msgId, "Ntt:TransceiverInfo"); + // const vaas: Uint8Array[] = [serialize(vaa!)]; // [target, peer, vaa] - const registrations: [string, string, VAA<"Ntt:TransceiverRegistration">][] = - []; + // const registrations: [string, string, VAA<"Ntt:TransceiverRegistration">][] = + // []; // register each chain in parallel await Promise.all( @@ -151,63 +166,64 @@ export async function link(chainInfos: Ctx[], accountantPrivateKey: string) { ); for (const peerInfo of toRegister) { - const vaa = await setupPeer(targetInfo, peerInfo); - if (!vaa) throw new Error("No VAA found"); + // const vaa = await setupPeer(targetInfo, peerInfo); + await setupPeer(targetInfo, peerInfo); + // if (!vaa) throw new Error("No VAA found"); // Add to registrations by PEER chain so we can register hub first - registrations.push([ - targetInfo.context.chain, - peerInfo.context.chain, - vaa, - ]); + // registrations.push([ + // targetInfo.context.chain, + // peerInfo.context.chain, + // vaa, + // ]); } })() ) ); // Push Hub to Spoke registrations - const hubToSpokeRegistrations = registrations.filter( - ([_, peer]) => peer === hubChain - ); - for (const [, , vaa] of hubToSpokeRegistrations) { - console.log( - "Pushing hub to spoke registrations: ", - vaa.emitterChain, - vaa.payload.chain, - vaa.payload.transceiver.toString() - ); - vaas.push(serialize(vaa)); - } + // const hubToSpokeRegistrations = registrations.filter( + // ([_, peer]) => peer === hubChain + // ); + // for (const [, , vaa] of hubToSpokeRegistrations) { + // console.log( + // "Pushing hub to spoke registrations: ", + // vaa.emitterChain, + // vaa.payload.chain, + // vaa.payload.transceiver.toString() + // ); + // vaas.push(serialize(vaa)); + // } // Push Spoke to Hub registrations - const spokeToHubRegistrations = registrations.filter( - ([target, _]) => target === hubChain - ); - for (const [, , vaa] of spokeToHubRegistrations) { - console.log( - "Pushing spoke to hub registrations: ", - vaa.emitterChain, - vaa.payload.chain, - vaa.payload.transceiver.toString() - ); - vaas.push(serialize(vaa)); - } + // const spokeToHubRegistrations = registrations.filter( + // ([target, _]) => target === hubChain + // ); + // for (const [, , vaa] of spokeToHubRegistrations) { + // console.log( + // "Pushing spoke to hub registrations: ", + // vaa.emitterChain, + // vaa.payload.chain, + // vaa.payload.transceiver.toString() + // ); + // vaas.push(serialize(vaa)); + // } // Push all other registrations - const spokeToSpokeRegistrations = registrations.filter( - ([target, peer]) => target !== hubChain && peer !== hubChain - ); - for (const [, , vaa] of spokeToSpokeRegistrations) { - console.log( - "Pushing spoke to spoke registrations: ", - vaa.emitterChain, - vaa.payload.chain, - vaa.payload.transceiver.toString() - ); - vaas.push(serialize(vaa)); - } + // const spokeToSpokeRegistrations = registrations.filter( + // ([target, peer]) => target !== hubChain && peer !== hubChain + // ); + // for (const [, , vaa] of spokeToSpokeRegistrations) { + // console.log( + // "Pushing spoke to spoke registrations: ", + // vaa.emitterChain, + // vaa.payload.chain, + // vaa.payload.transceiver.toString() + // ); + // vaas.push(serialize(vaa)); + // } // Submit all registrations at once - await submitAccountantVAAs(vaas, accountantPrivateKey); + // await submitAccountantVAAs(vaas, accountantPrivateKey); } export async function transferWithChecks(sourceCtx: Ctx, destinationCtx: Ctx) { @@ -245,15 +261,69 @@ export async function transferWithChecks(sourceCtx: Ctx, destinationCtx: Ctx) { automatic: useRelayer, gasDropoff: 0n, }); - const txids = await signSendWait(sourceCtx.context, transferTxs, srcSigner); + const txIds = await signSendWait(sourceCtx.context, transferTxs, srcSigner); + console.log(txIds); + + const sourceChainId = chainToChainId(sourceCtx.context.chain); + // TODO: executor sdk should get execution request IDs from a tx + const getExecutionIdsFromTx = async ( + txId: TransactionId + ): Promise => { + const executionIds: string[] = []; + const response = await axios.post(sourceCtx.context.config.rpc, { + jsonrpc: "2.0", + id: 1, + method: "eth_getTransactionReceipt", + params: [txId.txid], + }); + const logs = response?.data?.result?.logs; + if (logs) { + for (let logIndex = 0; logIndex < logs.length; logIndex++) { + const log = logs[logIndex]; + if ( + log && + log.removed === false && + log.address === EXECUTORS[sourceChainId]?.toLowerCase() && + log.topics.length === 2 && + log.topics[0] === + "0xd870d87e4a7c33d0943b0a3d2822b174e239cc55c169af14cc56467a4489e3b5" + ) { + executionIds.push( + `${sourceChainId + .toString(16) + .padStart(4, "0")}${txId.txid.substring(2)}${logIndex + .toString(16) + .padStart(64, "0")}` + ); + } + } + } + return executionIds; + }; + const executionIds = []; + for (const txId of txIds) { + executionIds.push(...(await getExecutionIdsFromTx(txId))); + } - const srcCore = await sourceCtx.context.getWormholeCore(); - const msgId = ( - await srcCore.parseTransaction(txids[txids.length - 1]!.txid) - )[0]!; + for (const executionId of executionIds) { + let isRelayed = false; + while (!isRelayed) { + const ret = await axios.get( + `http://executor:3000/v0/status/${executionId}` + ); + if (ret.data.status === "pending") { + await new Promise((resolve) => setTimeout(resolve, 1000)); + } else if (ret.data.status === "submitted") { + isRelayed = true; + } else { + throw new Error("error executing relay"); + } + } + } - if (!useRelayer) await receive(msgId, destinationCtx); - else await waitForRelay(msgId, destinationCtx); + // apparently we're checking before the transaction has settled + // TODO: wait for the tx to be included in a block + await new Promise((resolve) => setTimeout(resolve, 1000)); const [managerBalanceAfterSend, userBalanceAfterSend] = await getManagerAndUserBalance(sourceCtx); @@ -275,34 +345,6 @@ export async function transferWithChecks(sourceCtx: Ctx, destinationCtx: Ctx) { ); } -async function waitForRelay( - msgId: WormholeMessageId, - dst: Ctx, - retryTime: number = 2000 -) { - const vaa = await wh.getVaa(msgId, "Uint8Array"); - const deliveryHash = keccak256(vaa!.hash); - - const wormholeRelayer = IWormholeRelayer__factory.connect( - dst.context.config.contracts.relayer!, - await dst.context.getRpc() - ); - - let success = false; - while (!success) { - try { - const successBlock = await wormholeRelayer.deliverySuccessBlock( - deliveryHash - ); - if (successBlock > 0) success = true; - console.log("Relayer delivery: ", success); - } catch (e) { - console.error(e); - } - await new Promise((resolve) => setTimeout(resolve, retryTime)); - } -} - // Wrap signSendWait from sdk to provide full error message async function signSendWait( ctx: ChainContext, @@ -401,7 +443,17 @@ async function deployEvm(ctx: Ctx): Promise { console.log("Deploying manager implementation"); const wormholeManager = new NttManager__factory(myObj, wallet); + const endpoint = ENDPOINTS[chainId]; + if (!endpoint) { + throw new Error(`Endpoint is not specified for chain ${chainId}`); + } + const executor = EXECUTORS[chainId]; + if (!executor) { + throw new Error(`Executor is not specified for chain ${chainId}`); + } const managerAddress = await wormholeManager.deploy( + endpoint, + executor, ERC20NTTAddress, // Token address ctx.mode === "locking" ? 0 : 1, // Lock chainId, // chain id @@ -424,46 +476,23 @@ async function deployEvm(ctx: Ctx): Promise { wallet ); - console.log("Deploy transceiver implementation"); - const WormholeTransceiverFactory = new WormholeTransceiver__factory( - myObj, - wallet - ); - const WormholeTransceiverAddress = await WormholeTransceiverFactory.deploy( - // List of useful wormhole contracts - https://github.com/wormhole-foundation/wormhole/blob/00f504ef452ae2d94fa0024c026be2d8cf903ad5/ethereum/ts-scripts/relayer/config/ci/contracts.json - await manager.getAddress(), - ctx.context.config.contracts.coreBridge!, // Core wormhole contract - https://docs.wormhole.com/wormhole/blockchain-environments/evm#local-network-contract -- may need to be changed to support other chains - ctx.context.config.contracts.relayer!, // Relayer contract -- double check these...https://github.com/wormhole-foundation/wormhole/blob/main/sdk/js/src/relayer/__tests__/wormhole_relayer.ts - "0x0000000000000000000000000000000000000000", // TODO - Specialized relayer?????? - 200, // Consistency level - 500000n // Gas limit - ); - await WormholeTransceiverAddress.deploymentTransaction()?.wait(1); - - // Setup with the proxy - console.log("Deploy transceiver proxy"); - const transceiverProxyFactory = new ERC1967Proxy__factory(wallet); - const transceiverProxyDeployment = await transceiverProxyFactory.deploy( - await WormholeTransceiverAddress.getAddress(), - "0x" - ); - await transceiverProxyDeployment.deploymentTransaction()?.wait(1); - - const transceiverProxyAddress = await transceiverProxyDeployment.getAddress(); - const transceiver = WormholeTransceiver__factory.connect( - transceiverProxyAddress, - wallet - ); - // initialize() on both the manager and transceiver console.log("Initialize the manager"); await tryAndWaitThrice(() => manager.initialize()); - console.log("Initialize the transceiver"); - await tryAndWaitThrice(() => transceiver.initialize()); // Setup the initial calls, like transceivers for the manager + const adapter = WHG_ADAPTERS[chainId]; + if (!adapter) { + throw new Error(`Adapter is not specified for chain ${chainId}`); + } console.log("Set transceiver for manager"); - await tryAndWaitThrice(() => manager.setTransceiver(transceiverProxyAddress)); + await tryAndWaitThrice(() => manager.setTransceiver(adapter)); + await tryAndWaitThrice(() => + manager.enableSendTransceiver(chainId === 2 ? 4 : 2, adapter) + ); + await tryAndWaitThrice(() => + manager.enableRecvTransceiver(chainId === 2 ? 4 : 2, adapter) + ); console.log("Set outbound limit for manager"); await tryAndWaitThrice(() => @@ -474,7 +503,7 @@ async function deployEvm(ctx: Ctx): Promise { ...ctx, contracts: { transceiver: { - wormhole: transceiverProxyAddress, + wormhole: adapter, }, manager: await managerProxyAddress.getAddress(), token: ERC20NTTAddress, @@ -598,6 +627,7 @@ async function setupPeer(targetCtx: Ctx, peerCtx: Ctx) { const peerTransceiver = Wormhole.chainAddress(peer.chain, transceiver!); const tokenDecimals = target.config.nativeTokenDecimals; + const gasLimit = BigInt("200000"); const inboundLimit = amount.units(amount.parse("1000", tokenDecimals)); const { signer, address: sender } = targetCtx.signers; @@ -606,43 +636,23 @@ async function setupPeer(targetCtx: Ctx, peerCtx: Ctx) { const setPeerTxs = nttManager.setPeer( peerManager, tokenDecimals, + gasLimit, inboundLimit, sender.address ); await signSendWait(target, setPeerTxs, signer); - const setXcvrPeerTxs = nttManager.setTransceiverPeer( - 0, // 0 = Wormhole - peerTransceiver, - sender.address - ); - const xcvrPeerTxids = await signSendWait(target, setXcvrPeerTxs, signer); - const [whm] = await target.parseTransaction(xcvrPeerTxids[0]!.txid); + // const setXcvrPeerTxs = nttManager.setTransceiverPeer( + // 0, // 0 = Wormhole + // peerTransceiver, + // sender.address + // ); + // const xcvrPeerTxids = await signSendWait(target, setXcvrPeerTxs, signer); + // await signSendWait(target, setXcvrPeerTxs, signer); + // const [whm] = await target.parseTransaction(xcvrPeerTxids[0]!.txid); console.log("Set peers for: ", target.chain, peer.chain); - if ( - chainToPlatform(target.chain) === "Evm" && - chainToPlatform(peer.chain) === "Evm" - ) { - const nativeSigner = (signer as NativeSigner).unwrap(); - const xcvr = WormholeTransceiver__factory.connect( - targetCtx.contracts!.transceiver["wormhole"]!, - nativeSigner.signer - ); - const peerChainId = toChainId(peer.chain); - - console.log("Setting isEvmChain for: ", peer.chain); - await tryAndWaitThrice(() => - xcvr.setIsWormholeEvmChain.send(peerChainId, true) - ); - - console.log("Setting wormhole relaying for: ", peer.chain); - await tryAndWaitThrice(() => - xcvr.setIsWormholeRelayingEnabled.send(peerChainId, true) - ); - } - - return await wh.getVaa(whm!, "Ntt:TransceiverRegistration"); + // return await wh.getVaa(whm!, "Ntt:TransceiverRegistration"); } async function receive(msgId: WormholeMessageId, destination: Ctx) { @@ -731,7 +741,7 @@ async function tryAndWaitThrice( export async function testHub( source: Chain, destinationA: Chain, - destinationB: Chain, + // destinationB: Chain, getNativeSigner: (ctx: Partial) => any, accountantPrivateKey: string ) { @@ -739,35 +749,37 @@ export async function testHub( const hubChain = wh.getChain(source); const spokeChainA = wh.getChain(destinationA); - const spokeChainB = wh.getChain(destinationB); + // const spokeChainB = wh.getChain(destinationB); // Deploy contracts for hub chain console.log("Deploying contracts"); - const [hub, spokeA, spokeB] = await Promise.all([ + const [hub, spokeA] = await Promise.all([ deploy({ context: hubChain, mode: "locking" }, getNativeSigner), deploy({ context: spokeChainA, mode: "burning" }, getNativeSigner), - deploy({ context: spokeChainB, mode: "burning" }, getNativeSigner), + // deploy({ context: spokeChainB, mode: "burning" }, getNativeSigner), ]); console.log("Deployed: ", { [hub.context.chain]: hub.contracts, [spokeA.context.chain]: spokeA.contracts, - [spokeB.context.chain]: spokeB.contracts, + // [spokeB.context.chain]: spokeB.contracts, }); // Link contracts console.log("Linking Peers"); - await link([hub, spokeA, spokeB], accountantPrivateKey); + await link([hub, spokeA], accountantPrivateKey); // Transfer tokens from hub to spoke and check balances console.log("Transfer hub to spoke A"); await transferWithChecks(hub, spokeA); // Transfer between spokes and check balances - console.log("Transfer spoke A to spoke B"); - await transferWithChecks(spokeA, spokeB); + // console.log("Transfer spoke A to spoke B"); + // await transferWithChecks(spokeA, spokeB); // Transfer back to hub and check balances - console.log("Transfer spoke B to hub"); - await transferWithChecks(spokeB, hub); + // console.log("Transfer spoke B to hub"); + // await transferWithChecks(spokeB, hub); + console.log("Transfer spoke A to hub"); + await transferWithChecks(spokeA, hub); } diff --git a/sdk/definitions/src/ntt.ts b/sdk/definitions/src/ntt.ts index 485d1cd24..176990068 100644 --- a/sdk/definitions/src/ntt.ts +++ b/sdk/definitions/src/ntt.ts @@ -91,6 +91,7 @@ export namespace Ntt { export type Peer = { address: ChainAddress; tokenDecimals: number; + gasLimit: bigint; inboundLimit: bigint; }; @@ -182,11 +183,12 @@ export interface Ntt { payer?: AccountAddress ): AsyncGenerator>; - getThreshold(): Promise; + getThreshold(chainId: number): Promise; setPeer( peer: ChainAddress, tokenDecimals: number, + gasLimit: bigint, inboundLimit: bigint, payer?: AccountAddress ): AsyncGenerator>; diff --git a/solana/tests/anchor.test.ts b/solana/tests/anchor.test.ts index 16ba7319b..5b61831fb 100644 --- a/solana/tests/anchor.test.ts +++ b/solana/tests/anchor.test.ts @@ -266,7 +266,7 @@ describe("example-native-token-transfers", () => { await signSendWait(ctx, setXcvrPeerTxs, signer); // Set manager peer - const setPeerTxs = ntt.setPeer(remoteMgr, 18, 1000000n, sender); + const setPeerTxs = ntt.setPeer(remoteMgr, 18, 1n, 1000000n, sender); await signSendWait(ctx, setPeerTxs, signer); } catch (e) { console.error("Failed to setup peer: ", e); diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index 3e8982d2b..d70729634 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -598,6 +598,7 @@ export class SolanaNtt address: toUniversal(chain, new Uint8Array(peer.address)), }, tokenDecimals: peer.tokenDecimals, + gasLimit: BigInt(0), //TODO: read this from peer account inboundLimit: await this.getInboundLimit(chain), }; } @@ -767,6 +768,7 @@ export class SolanaNtt async *setPeer( peer: ChainAddress, tokenDecimals: number, + _gasLimit: bigint, inboundLimit: bigint, payer: AccountAddress ) { diff --git a/tilt/Dockerfile.deploy b/tilt/Dockerfile.deploy new file mode 100644 index 000000000..23cfc7134 --- /dev/null +++ b/tilt/Dockerfile.deploy @@ -0,0 +1,40 @@ +FROM --platform=linux/amd64 ghcr.io/foundry-rs/foundry@sha256:8b843eb65cc7b155303b316f65d27173c862b37719dc095ef3a2ef27ce8d3c00 as builder + +RUN apk add jq bash + +WORKDIR /app/example-messaging-endpoint + +RUN git init && \ + git remote add origin https://github.com/wormholelabs-xyz/example-messaging-endpoint && \ + git fetch --depth 1 origin 0f853ea0335937d611217f5048d677a4f46249fd && \ + git checkout FETCH_HEAD + +WORKDIR /app/example-messaging-endpoint/evm + +RUN forge build + +WORKDIR /app/example-messaging-executor + +RUN git init && \ + git remote add origin https://github.com/wormholelabs-xyz/example-messaging-executor && \ + git fetch --depth 1 origin 57c49d9ad7c410b9a7f938e07a5444f07872159d && \ + git checkout FETCH_HEAD + +WORKDIR /app/example-messaging-executor/evm + +RUN forge build + +WORKDIR /app/example-messaging-adapter-wormhole-guardians + +RUN git init && \ + git remote add origin https://github.com/wormholelabs-xyz/example-messaging-adapter-wormhole-guardians && \ + git fetch --depth 1 origin e2172453c64bc072d0aaa9e9c5d2057d6b56d741 && \ + git checkout FETCH_HEAD + +WORKDIR /app/example-messaging-adapter-wormhole-guardians/evm + +RUN forge build + +WORKDIR /app + +COPY deploy.sh deploy.sh diff --git a/tilt/Dockerfile.executor b/tilt/Dockerfile.executor new file mode 100644 index 000000000..193185dc2 --- /dev/null +++ b/tilt/Dockerfile.executor @@ -0,0 +1,13 @@ +FROM node:20.11.1-alpine@sha256:f4c96a28c0b2d8981664e03f461c2677152cd9a756012ffa8e2c6727427c2bda + +RUN apk add git + +WORKDIR /usr/src/ + +RUN git init && \ + git remote add origin https://github.com/wormholelabs-xyz/example-messaging-executor && \ + git fetch --depth 1 origin 0b0ae41d2e3c8dbda3107074080ad586021f75a9 && \ + git checkout FETCH_HEAD + +RUN --mount=type=cache,uid=1000,gid=1000,target=/home/node/.npm \ + npm ci diff --git a/tilt/deploy.sh b/tilt/deploy.sh new file mode 100644 index 000000000..e92a643a8 --- /dev/null +++ b/tilt/deploy.sh @@ -0,0 +1,29 @@ +#!/bin/sh + +cd /app/example-messaging-endpoint/evm +RPC_URL=http://eth-devnet:8545 bash ./sh/deployEndpoint.sh +OUR_CHAIN_ID=4 EVM_CHAIN_ID=1397 RPC_URL=http://eth-devnet2:8545 bash ./sh/deployEndpoint.sh + +cd /app/example-messaging-executor/evm +RPC_URL=http://eth-devnet:8545 bash ./sh/deployExecutor.sh +OUR_CHAIN_ID=4 EVM_CHAIN_ID=1397 RPC_URL=http://eth-devnet2:8545 bash ./sh/deployExecutor.sh + +cd /app/example-messaging-adapter-wormhole-guardians/evm + +export ENDPOINT=$(jq -r '.returns.deployedAddress.value' <<< cat /app/example-messaging-endpoint/evm/broadcast/DeployEndpoint.s.sol/1337/run-latest.json) +export EXECUTOR=$(jq -r '.returns.deployedAddress.value' <<< cat /app/example-messaging-executor/evm/broadcast/DeployExecutor.s.sol/1337/run-latest.json) +RPC_URL=http://eth-devnet:8545 bash ./sh/deployWormholeGuardiansAdapterWithExecutor.sh + +export ENDPOINT=$(jq -r '.returns.deployedAddress.value' <<< cat /app/example-messaging-endpoint/evm/broadcast/DeployEndpoint.s.sol/1397/run-latest.json) +export EXECUTOR=$(jq -r '.returns.deployedAddress.value' <<< cat /app/example-messaging-executor/evm/broadcast/DeployExecutor.s.sol/1397/run-latest.json) +OUR_CHAIN_ID=4 EVM_CHAIN_ID=1397 RPC_URL=http://eth-devnet2:8545 bash ./sh/deployWormholeGuardiansAdapterWithExecutor.sh + +export WGA_ADDR=$(jq -r '.returns.deployedAddress.value' <<< cat ./broadcast/DeployWormholeGuardiansAdapterWithExecutor.s.sol/1337/run-latest.json) +export PEER_CHAIN_ID=4 +export PEER_ADDR="0x000000000000000000000000$(jq -r '.returns.deployedAddress.value' <<< cat ./broadcast/DeployWormholeGuardiansAdapterWithExecutor.s.sol/1397/run-latest.json | cut -d 'x' -f2)" +RPC_URL=http://eth-devnet:8545 bash ./sh/setPeer.sh + +export WGA_ADDR=$(jq -r '.returns.deployedAddress.value' <<< cat ./broadcast/DeployWormholeGuardiansAdapterWithExecutor.s.sol/1397/run-latest.json) +export PEER_CHAIN_ID=2 +export PEER_ADDR="0x000000000000000000000000$(jq -r '.returns.deployedAddress.value' <<< cat ./broadcast/DeployWormholeGuardiansAdapterWithExecutor.s.sol/1337/run-latest.json | cut -d 'x' -f2)" +RPC_URL=http://eth-devnet2:8545 bash ./sh/setPeer.sh diff --git a/tilt/executor-deploy.yaml b/tilt/executor-deploy.yaml new file mode 100644 index 000000000..61dbb6b2d --- /dev/null +++ b/tilt/executor-deploy.yaml @@ -0,0 +1,24 @@ +kind: Job +apiVersion: batch/v1 +metadata: + name: executor-deploy +spec: + backoffLimit: 0 + template: + spec: + restartPolicy: Never + containers: + - name: deploy + image: executor-deploy + command: + - /bin/sh + - -c + - "bash ./deploy.sh && touch /success" + readinessProbe: + exec: + command: + - test + - -e + - "/success" + initialDelaySeconds: 5 + periodSeconds: 5 diff --git a/tilt/executor.yaml b/tilt/executor.yaml new file mode 100644 index 000000000..77844db40 --- /dev/null +++ b/tilt/executor.yaml @@ -0,0 +1,48 @@ +--- +apiVersion: v1 +kind: Service +metadata: + name: executor + labels: + app: executor +spec: + clusterIP: None + selector: + app: executor + ports: + - port: 3000 + name: express + protocol: TCP +--- +apiVersion: apps/v1 +kind: StatefulSet +metadata: + name: executor +spec: + selector: + matchLabels: + app: executor + serviceName: executor + template: + metadata: + labels: + app: executor + spec: + restartPolicy: Always + terminationGracePeriodSeconds: 0 + containers: + - name: executor + image: executor + command: + - /bin/sh + - -c + - "npm start" + readinessProbe: + tcpSocket: + port: 3000 + periodSeconds: 1 + failureThreshold: 300 + ports: + - containerPort: 3000 + name: executor + protocol: TCP