From f57e77ab5ebbd4892f0530d1282b5d3df60dcc95 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Fri, 26 Jan 2024 18:10:27 -0600 Subject: [PATCH 01/17] Feature: Native Token Transfers (NTT) integration Addresses #1585 --- builder/src/consts.ts | 14 + package-lock.json | 61 + sdk/src/config/TESTNET.ts | 2 +- wormhole-connect/package.json | 4 +- wormhole-connect/src/AppRouter.tsx | 4 + wormhole-connect/src/config/routes.ts | 16 + .../src/config/testnet/gasEstimates.ts | 35 + wormhole-connect/src/config/testnet/tokens.ts | 109 + wormhole-connect/src/config/types.ts | 9 + .../hooks/useCheckInboundQueuedTransfer.ts | 68 + .../src/hooks/useDeliveryStatus.ts | 82 + .../src/hooks/usePorticoRelayerFee.ts | 6 +- wormhole-connect/src/icons/RouteIcons.tsx | 6 + wormhole-connect/src/icons/TokenIcons.tsx | 2 + wormhole-connect/src/icons/Tokens/NTT.tsx | 84 + .../src/routes/abstracts/routeAbstract.ts | 3 +- .../src/routes/bridge/baseRoute.ts | 8 + wormhole-connect/src/routes/bridge/bridge.ts | 10 +- .../src/routes/cctpManual/cctpManual.ts | 8 +- .../src/routes/cctpRelay/cctpRelay.ts | 9 +- .../src/routes/cosmosGateway/cosmosGateway.ts | 9 +- .../src/routes/hashflow/hashflow.ts | 3 +- wormhole-connect/src/routes/ntt/errors.ts | 34 + wormhole-connect/src/routes/ntt/index.ts | 6 + wormhole-connect/src/routes/ntt/nttBase.ts | 447 +++ wormhole-connect/src/routes/ntt/nttManual.ts | 8 + wormhole-connect/src/routes/ntt/nttRelay.ts | 238 ++ .../src/routes/ntt/payloads/common.ts | 120 + .../src/routes/ntt/payloads/transfers.ts | 50 + .../src/routes/ntt/payloads/trimmedAmount.ts | 22 + .../src/routes/ntt/payloads/wormhole.ts | 5 + .../ntt/platforms/evm/abis/NttManager.ts | 1888 ++++++++++ .../platforms/evm/abis/NttManager__factory.ts | 1858 +++++++++ .../platforms/evm/abis/WormholeTransceiver.ts | 1446 +++++++ .../evm/abis/WormholeTransceiver__factory.ts | 1351 +++++++ .../routes/ntt/platforms/evm/abis/common.ts | 46 + .../routes/ntt/platforms/evm/abis/index.ts | 3 + .../routes/ntt/platforms/evm/getMessage.ts | 117 + .../src/routes/ntt/platforms/evm/index.ts | 3 + .../routes/ntt/platforms/evm/nttManager.ts | 232 ++ .../ntt/platforms/evm/wormholeTransceiver.ts | 46 + .../src/routes/ntt/platforms/index.ts | 17 + .../routes/ntt/platforms/solana/getMessage.ts | 105 + .../src/routes/ntt/platforms/solana/index.ts | 2 + .../routes/ntt/platforms/solana/nttManager.ts | 788 ++++ .../routes/ntt/platforms/solana/nttQuoter.ts | 154 + .../types/example_native_token_transfers.ts | 3341 +++++++++++++++++ .../ntt/platforms/solana/types/ntt_quoter.ts | 885 +++++ wormhole-connect/src/routes/ntt/types.ts | 5 + wormhole-connect/src/routes/ntt/utils.ts | 77 + wormhole-connect/src/routes/operator.ts | 43 +- .../src/routes/porticoBridge/porticoBridge.ts | 12 +- wormhole-connect/src/routes/relay/relay.ts | 9 +- wormhole-connect/src/routes/tbtc/tbtc.ts | 9 +- wormhole-connect/src/routes/types.ts | 40 +- wormhole-connect/src/routes/utils.ts | 6 +- wormhole-connect/src/store/helpers.ts | 5 + wormhole-connect/src/store/index.ts | 2 + wormhole-connect/src/store/ntt.ts | 40 + wormhole-connect/src/store/redeem.ts | 20 +- wormhole-connect/src/store/transferInput.ts | 25 +- wormhole-connect/src/utils/index.ts | 19 +- .../src/utils/transferValidation.ts | 8 +- wormhole-connect/src/utils/vaa.ts | 52 +- wormhole-connect/src/utils/wallet/index.ts | 3 +- wormhole-connect/src/views/Bridge/Bridge.tsx | 4 +- .../src/views/Bridge/Inputs/TokenWarnings.tsx | 9 +- .../Bridge/NttInboundCapacityWarning.tsx | 115 + wormhole-connect/src/views/Bridge/Preview.tsx | 9 +- wormhole-connect/src/views/Bridge/Send.tsx | 14 +- .../src/views/Redeem/NttInboundQueued.tsx | 215 ++ .../src/views/Redeem/NttStepper.tsx | 63 + wormhole-connect/src/views/Redeem/Redeem.tsx | 18 +- .../views/Redeem/RelayerDeliveryFailed.tsx | 62 + wormhole-connect/src/views/Redeem/SendTo.tsx | 51 +- 75 files changed, 14613 insertions(+), 86 deletions(-) create mode 100644 wormhole-connect/src/hooks/useCheckInboundQueuedTransfer.ts create mode 100644 wormhole-connect/src/hooks/useDeliveryStatus.ts create mode 100644 wormhole-connect/src/icons/Tokens/NTT.tsx create mode 100644 wormhole-connect/src/routes/ntt/errors.ts create mode 100644 wormhole-connect/src/routes/ntt/index.ts create mode 100644 wormhole-connect/src/routes/ntt/nttBase.ts create mode 100644 wormhole-connect/src/routes/ntt/nttManual.ts create mode 100644 wormhole-connect/src/routes/ntt/nttRelay.ts create mode 100644 wormhole-connect/src/routes/ntt/payloads/common.ts create mode 100644 wormhole-connect/src/routes/ntt/payloads/transfers.ts create mode 100644 wormhole-connect/src/routes/ntt/payloads/trimmedAmount.ts create mode 100644 wormhole-connect/src/routes/ntt/payloads/wormhole.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager__factory.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver__factory.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/abis/common.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/abis/index.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/index.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/nttManager.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/evm/wormholeTransceiver.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/index.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/solana/index.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/solana/nttQuoter.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/solana/types/example_native_token_transfers.ts create mode 100644 wormhole-connect/src/routes/ntt/platforms/solana/types/ntt_quoter.ts create mode 100644 wormhole-connect/src/routes/ntt/types.ts create mode 100644 wormhole-connect/src/routes/ntt/utils.ts create mode 100644 wormhole-connect/src/store/ntt.ts create mode 100644 wormhole-connect/src/views/Bridge/NttInboundCapacityWarning.tsx create mode 100644 wormhole-connect/src/views/Redeem/NttInboundQueued.tsx create mode 100644 wormhole-connect/src/views/Redeem/NttStepper.tsx create mode 100644 wormhole-connect/src/views/Redeem/RelayerDeliveryFailed.tsx diff --git a/builder/src/consts.ts b/builder/src/consts.ts index 6795c9342..5f9238a8d 100644 --- a/builder/src/consts.ts +++ b/builder/src/consts.ts @@ -253,6 +253,20 @@ export const ROUTE_INFOS: RouteInfo[] = [ title: "wstETH Bridge", description: "Permissionlessly transfer wstETH cross-chain with Wormhole.", }, + { + key: "nttManual", + title: "Native Token Transfer", + description: + "Permissionlessly transfer native tokens cross-chain with Wormhole.", + link: "https://github.com/wormhole-foundation/example-native-token-transfers/blob/main/README.md", + }, + { + key: "nttRelay", + title: "Native Token Transfer Automatic Redeems", + description: + "Automatic redeems for Native Token Transfers powered by xLabs.", + link: "https://github.com/wormhole-foundation/example-native-token-transfers/blob/main/README.md", + }, ]; export const ROUTES = ROUTE_INFOS.map((r) => r.key); diff --git a/package-lock.json b/package-lock.json index 329a67e27..61ac29651 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2229,6 +2229,66 @@ "pbts": "bin/pbts" } }, + "node_modules/@coral-xyz/anchor": { + "version": "0.29.0", + "resolved": "https://registry.npmjs.org/@coral-xyz/anchor/-/anchor-0.29.0.tgz", + "integrity": "sha512-eny6QNG0WOwqV0zQ7cs/b1tIuzZGmP7U7EcH+ogt4Gdbl8HDmIYVMh/9aTmYZPaFWjtUaI8qSn73uYEXWfATdA==", + "dependencies": { + "@coral-xyz/borsh": "^0.29.0", + "@noble/hashes": "^1.3.1", + "@solana/web3.js": "^1.68.0", + "bn.js": "^5.1.2", + "bs58": "^4.0.1", + "buffer-layout": "^1.2.2", + "camelcase": "^6.3.0", + "cross-fetch": "^3.1.5", + "crypto-hash": "^1.3.0", + "eventemitter3": "^4.0.7", + "pako": "^2.0.3", + "snake-case": "^3.0.4", + "superstruct": "^0.15.4", + "toml": "^3.0.0" + }, + "engines": { + "node": ">=11" + } + }, + "node_modules/@coral-xyz/anchor/node_modules/@coral-xyz/borsh": { + "version": "0.29.0", + "resolved": "https://registry.npmjs.org/@coral-xyz/borsh/-/borsh-0.29.0.tgz", + "integrity": "sha512-s7VFVa3a0oqpkuRloWVPdCK7hMbAMY270geZOGfCnaqexrP5dTIpbEHL33req6IYPPJ0hYa71cdvJ1h6V55/oQ==", + "dependencies": { + "bn.js": "^5.1.2", + "buffer-layout": "^1.2.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@solana/web3.js": "^1.68.0" + } + }, + "node_modules/@coral-xyz/anchor/node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@coral-xyz/anchor/node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==" + }, + "node_modules/@coral-xyz/anchor/node_modules/superstruct": { + "version": "0.15.5", + "resolved": "https://registry.npmjs.org/superstruct/-/superstruct-0.15.5.tgz", + "integrity": "sha512-4AOeU+P5UuE/4nOUkmcQdW5y7i9ndt1cQd/3iUe+LTz3RxESf/W/5lg4B74HbDMMv8PHnPnGCQFH45kBcrQYoQ==" + }, "node_modules/@coral-xyz/borsh": { "version": "0.2.6", "resolved": "https://registry.npmjs.org/@coral-xyz/borsh/-/borsh-0.2.6.tgz", @@ -36535,6 +36595,7 @@ "version": "0.0.1-beta.0", "dependencies": { "@certusone/wormhole-sdk": "^0.10.10", + "@coral-xyz/anchor": "^0.29.0", "@cosmjs/cosmwasm-stargate": "^0.31.3", "@cosmjs/stargate": "^0.31.3", "@cosmjs/tendermint-rpc": "^0.31.3", diff --git a/sdk/src/config/TESTNET.ts b/sdk/src/config/TESTNET.ts index b8e8687ed..7a431b594 100644 --- a/sdk/src/config/TESTNET.ts +++ b/sdk/src/config/TESTNET.ts @@ -397,7 +397,7 @@ const TESTNET_CONFIG: WormholeConfig = { klaytn: 'https://rpc.ankr.com/klaytn_testnet', sepolia: 'https://rpc.ankr.com/eth_sepolia', arbitrum_sepolia: 'https://sepolia-rollup.arbitrum.io/rpc', - base_sepolia: 'https://sepolia.base.org', + base_sepolia: 'https://base-sepolia-rpc.publicnode.com', optimism_sepolia: 'https://sepolia.optimism.io', }, rest: { diff --git a/wormhole-connect/package.json b/wormhole-connect/package.json index f3e8148fe..1cdea723a 100644 --- a/wormhole-connect/package.json +++ b/wormhole-connect/package.json @@ -18,6 +18,7 @@ ], "dependencies": { "@certusone/wormhole-sdk": "^0.10.10", + "@coral-xyz/anchor": "^0.29.0", "@cosmjs/cosmwasm-stargate": "^0.31.3", "@cosmjs/stargate": "^0.31.3", "@cosmjs/tendermint-rpc": "^0.31.3", @@ -62,7 +63,8 @@ "prettier": "prettier --write ./src", "analyze": "NODE_ENV=production NODE_OPTIONS=--max-old-space-size=6144 vite-bundle-visualizer", "test": "jest ./tests/*.test.ts --detectOpenHandles", - "checksdn": "npx tsx scripts/ofac/checkSdnListForUpdates.ts" + "checksdn": "npx tsx scripts/ofac/checkSdnListForUpdates.ts", + "preview": "vite preview" }, "eslintConfig": { "extends": [ diff --git a/wormhole-connect/src/AppRouter.tsx b/wormhole-connect/src/AppRouter.tsx index 700f84ddf..3c29ac9c5 100644 --- a/wormhole-connect/src/AppRouter.tsx +++ b/wormhole-connect/src/AppRouter.tsx @@ -19,6 +19,8 @@ import { setRoute } from './store/router'; import { clearWallets } from './store/wallet'; import { clearPorticoBridge } from 'store/porticoBridge'; import { useExternalSearch } from 'hooks/useExternalSearch'; +import { clearNtt } from 'store/ntt'; +import internalConfig from 'config'; const useStyles = makeStyles()((theme: any) => ({ appContent: { @@ -71,6 +73,8 @@ function AppRouter({ config }: Props) { if (prevRoute === redeemRoute && route !== redeemRoute) { dispatch(clearRedeem()); dispatch(clearWallets()); + dispatch(clearNtt()); + internalConfig.wh.registerProviders(); // reset providers that may have been set during transfer } // reset transfer state on leave if (prevRoute === bridgeRoute && route !== bridgeRoute) { diff --git a/wormhole-connect/src/config/routes.ts b/wormhole-connect/src/config/routes.ts index cd621f7c4..6b1ceab66 100644 --- a/wormhole-connect/src/config/routes.ts +++ b/wormhole-connect/src/config/routes.ts @@ -91,4 +91,20 @@ export const RoutesConfig: { icon: WormholeIcon, pendingMessage: 'Waiting for Wormhole network consensus . . .', }, + [Route.NttManual]: { + route: Route.NttManual, + name: 'Native Token Transfer', + providedBy: 'Wormhole', + link: 'https://wormhole.com/', + icon: WormholeIcon, + pendingMessage: 'Waiting for Wormhole network consensus . . .', + }, + [Route.NttRelay]: { + route: Route.NttRelay, + name: 'Native Token Transfer', + providedBy: 'xLabs', + link: 'https://xlabs.xyz', + icon: XLabsIcon, + pendingMessage: 'Waiting for Wormhole network consensus . . .', + }, }; diff --git a/wormhole-connect/src/config/testnet/gasEstimates.ts b/wormhole-connect/src/config/testnet/gasEstimates.ts index b300d5ea6..96bb240a4 100644 --- a/wormhole-connect/src/config/testnet/gasEstimates.ts +++ b/wormhole-connect/src/config/testnet/gasEstimates.ts @@ -118,6 +118,13 @@ export const TESTNET_GAS_ESTIMATES: GasEstimates = { sendToken: 5000, claim: 5000, }, + [Route.NttManual]: { + sendToken: 15000, + claim: 25000, + }, + [Route.NttRelay]: { + sendToken: 15000, + }, }, sui: { [Route.Bridge]: { @@ -248,6 +255,13 @@ export const TESTNET_GAS_ESTIMATES: GasEstimates = { sendToken: 150000, claim: 200000, }, + [Route.NttManual]: { + sendToken: 200000, + claim: 250000, + }, + [Route.NttRelay]: { + sendToken: 450000, + }, }, arbitrum_sepolia: { [Route.Bridge]: { @@ -255,6 +269,13 @@ export const TESTNET_GAS_ESTIMATES: GasEstimates = { sendToken: 150000, claim: 200000, }, + [Route.NttManual]: { + sendToken: 200000, + claim: 250000, + }, + [Route.NttRelay]: { + sendToken: 450000, + }, }, base_sepolia: { [Route.Bridge]: { @@ -262,6 +283,13 @@ export const TESTNET_GAS_ESTIMATES: GasEstimates = { sendToken: 150000, claim: 200000, }, + [Route.NttManual]: { + sendToken: 200000, + claim: 250000, + }, + [Route.NttRelay]: { + sendToken: 450000, + }, }, optimism_sepolia: { [Route.Bridge]: { @@ -269,6 +297,13 @@ export const TESTNET_GAS_ESTIMATES: GasEstimates = { sendToken: 150000, claim: 200000, }, + [Route.NttManual]: { + sendToken: 200000, + claim: 250000, + }, + [Route.NttRelay]: { + sendToken: 450000, + }, }, injective: { [Route.Bridge]: { diff --git a/wormhole-connect/src/config/testnet/tokens.ts b/wormhole-connect/src/config/testnet/tokens.ts index 5b766c716..9b6006550 100644 --- a/wormhole-connect/src/config/testnet/tokens.ts +++ b/wormhole-connect/src/config/testnet/tokens.ts @@ -2232,4 +2232,113 @@ export const TESTNET_TOKENS: TokensConfig = { default: 18, }, }, + TEST_NTTsepolia: { + key: 'TEST_NTTsepolia', + symbol: 'TEST_NTT', + nativeChain: 'sepolia', + icon: Icon.NTT, + tokenId: { + chain: 'sepolia', + address: '0x1d30E78B7C7fbbcef87ae6e97B5389b2e470CA4a', + }, + coinGeckoId: '', + color: '#2774CA', + decimals: { + Ethereum: 18, + default: 8, + }, + ntt: { + groupId: 'test_ntt', + nttManager: '0xB231aD95f2301bc82eA44c515001F0F746D637e0', + wormholeTransceiver: '0x1fDC902e30b188FD2BA976B421Cb179943F57896', + }, + }, + TEST_NTTarbitrum_sepolia: { + key: 'TEST_NTTarbitrum_sepolia', + symbol: 'TEST_NTT', + nativeChain: 'arbitrum_sepolia', + icon: Icon.NTT, + tokenId: { + chain: 'arbitrum_sepolia', + address: '0x84A1Cb660B19eB0063EE5FD377eC14AAe3364d74', + }, + coinGeckoId: '', + color: '#2774CA', + decimals: { + Ethereum: 18, + default: 8, + }, + ntt: { + groupId: 'test_ntt', + nttManager: '0xEec94CD3083e067398256a79CcA7e740C5c8ef81', + wormholeTransceiver: '0x0E24D17D7467467b39Bf64A9DFf88776Bd6c74d7', + }, + }, + TEST_NTTbase_sepolia: { + key: 'TEST_NTTbase_sepolia', + symbol: 'TEST_NTT', + nativeChain: 'base_sepolia', + icon: Icon.NTT, + tokenId: { + chain: 'base_sepolia', + address: '0x7f430D4e7939D994C0955A01FC75D9DE33F12D11', + }, + coinGeckoId: '', + color: '#2774CA', + decimals: { + Ethereum: 18, + default: 8, + }, + ntt: { + groupId: 'test_ntt', + nttManager: '0xB03b030b2f5B40819Df76467d67eD1C85Ff66fAD', + wormholeTransceiver: '0x1e072169541f1171e427Aa44B5fd8924BEE71b0e', + }, + }, + TEST_NTToptimism_sepolia: { + key: 'TEST_NTToptimism_sepolia', + symbol: 'TEST_NTT', + nativeChain: 'optimism_sepolia', + icon: Icon.NTT, + tokenId: { + chain: 'optimism_sepolia', + address: '0x0e15979a7a1eFAEf20312CA45A59eb141bF7E340', + }, + coinGeckoId: '', + color: '#2774CA', + decimals: { + Ethereum: 18, + default: 8, + }, + ntt: { + groupId: 'test_ntt', + nttManager: '0x7f430D4e7939D994C0955A01FC75D9DE33F12D11', + wormholeTransceiver: '0x41265eb2863bf0238081F6AeefeF73549C82C3DD', + }, + }, + TEST_NTTsolana: { + key: 'TEST_NTTsolana', + symbol: 'TEST_NTT', + nativeChain: 'solana', + icon: Icon.NTT, + tokenId: { + chain: 'solana', + address: '87r5ZS91Q2pQbFTvvneqs7y7mbtegtqMt4LDAS4g23Ax', + }, + coinGeckoId: '', + color: '#2774CA', + decimals: { + Solana: 9, + default: 8, + }, + ntt: { + groupId: 'test_ntt', + nttManager: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', + // The wormhole transceiver is baked into the Solana NTT contract. + // If the transceiver is split into a separate contract, this address + // and route code should be updated to support the new structure. + wormholeTransceiver: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', + solanaQuoter: 'NqTdGLLL6b6bFo7YESNEezocgF8onH5cst5EdH791en', + }, + }, }; diff --git a/wormhole-connect/src/config/types.ts b/wormhole-connect/src/config/types.ts index 13cca7bf2..f92b7633d 100644 --- a/wormhole-connect/src/config/types.ts +++ b/wormhole-connect/src/config/types.ts @@ -41,6 +41,7 @@ export enum Icon { 'PYTH', 'INJ', 'KLAY', + 'NTT', } export enum Route { @@ -53,6 +54,8 @@ export enum Route { TBTC = 'tbtc', ETHBridge = 'ethBridge', wstETHBridge = 'wstETHBridge', + NttManual = 'nttManual', + NttRelay = 'nttRelay', } // Used in bridging components @@ -233,6 +236,12 @@ export type TokenConfig = { decimals: number; }; }; + ntt?: { + groupId: string; + nttManager: string; + wormholeTransceiver: string; + solanaQuoter?: string; + }; }; export type TokensConfig = { [key: string]: TokenConfig }; diff --git a/wormhole-connect/src/hooks/useCheckInboundQueuedTransfer.ts b/wormhole-connect/src/hooks/useCheckInboundQueuedTransfer.ts new file mode 100644 index 000000000..b60309098 --- /dev/null +++ b/wormhole-connect/src/hooks/useCheckInboundQueuedTransfer.ts @@ -0,0 +1,68 @@ +import { useEffect } from 'react'; +import { useDispatch, useSelector } from 'react-redux'; +import { RootState } from 'store'; +import { sleep } from 'utils'; +import { + resetInboundQueuedTransfer, + setInboundQueuedTransfer, +} from 'store/ntt'; +import { isSignedNttMessage } from 'routes/types'; +import { isNttRoute } from 'routes'; +import RouteOperator from 'routes/operator'; +import { NttBase } from 'routes/ntt/nttBase'; + +const RETRY_DELAY = 15_000; + +const useCheckInboundQueuedTransfer = (): void => { + const dispatch = useDispatch(); + const route = useSelector((state: RootState) => state.redeem.route); + const signedMessage = useSelector( + (state: RootState) => state.redeem.signedMessage, + ); + const transferComplete = useSelector( + (state: RootState) => state.redeem.transferComplete, + ); + + useEffect(() => { + dispatch(resetInboundQueuedTransfer()); + if ( + !route || + !isNttRoute(route) || + !signedMessage || + !isSignedNttMessage(signedMessage) || + transferComplete + ) { + return; + } + const { toChain, recipientNttManager, messageDigest } = signedMessage; + const nttRoute = RouteOperator.getRoute(route) as NttBase; + let active = true; + const fetchData = async () => { + // We continue polling for the inbound queued transfer even after fetching the data once, + // because the transfer could be released by anyone. + while (active) { + try { + const queuedTransfer = await nttRoute.getInboundQueuedTransfer( + toChain, + recipientNttManager, + messageDigest, + ); + if (active) { + dispatch(setInboundQueuedTransfer(queuedTransfer)); + } + } catch (e) { + console.error(e); + } + if (active) { + await sleep(RETRY_DELAY); + } + } + }; + fetchData(); + return () => { + active = false; + }; + }, [route, transferComplete, signedMessage]); +}; + +export default useCheckInboundQueuedTransfer; diff --git a/wormhole-connect/src/hooks/useDeliveryStatus.ts b/wormhole-connect/src/hooks/useDeliveryStatus.ts new file mode 100644 index 000000000..6a974d6e3 --- /dev/null +++ b/wormhole-connect/src/hooks/useDeliveryStatus.ts @@ -0,0 +1,82 @@ +import { DeliveryStatus } from '@certusone/wormhole-sdk/lib/esm/relayer'; +import axios from 'axios'; +import { Route } from 'config/types'; +import { useEffect } from 'react'; +import { useDispatch, useSelector } from 'react-redux'; +import { RootState } from 'store'; +import { setRedeemTx, setDeliveryStatus } from 'store/redeem'; +import { sleep } from 'utils'; +import { isEvmChain } from 'utils/sdk'; +import { getEmitterAndSequence } from 'utils/vaa'; +import config from 'config'; + +const RETRY_DELAY = 15_000; + +interface RelayResponse { + data?: { + delivery?: { + execution?: { + status: DeliveryStatus; + }; + }; + toTxHash?: string; + }; +} + +// Polls for standard relayer delivery status +const useDeliveryStatus = (): void => { + const dispatch = useDispatch(); + const route = useSelector((state: RootState) => state.redeem.route); + const signedMessage = useSelector( + (state: RootState) => state.redeem.signedMessage, + ); + useEffect(() => { + if ( + !signedMessage || + route !== Route.NttRelay || + // Currently, only EVM chains support standard relayer + !isEvmChain(signedMessage.toChain) || + !isEvmChain(signedMessage.fromChain) + ) { + return; + } + const { emitterChain, emitterAddress, sequence } = + getEmitterAndSequence(signedMessage); + const baseUrl = `https://api.${ + config.isMainnet ? '' : 'testnet.' + }wormholescan.io/api/v1/relays`; + let active = true; + const fetchData = async () => { + while (active) { + try { + const response = await axios.get( + `${baseUrl}/${emitterChain}/${emitterAddress}/${sequence}`, + ); + if (active) { + const { delivery, toTxHash } = response.data?.data || {}; + if (delivery?.execution) { + dispatch(setDeliveryStatus(delivery.execution.status)); + } + if (toTxHash) { + dispatch(setRedeemTx(toTxHash)); + } + break; + } + } catch (e) { + if (!axios.isAxiosError(e) || e.status !== 404) { + console.error(e); + } + } + if (active) { + await sleep(RETRY_DELAY); + } + } + }; + fetchData(); + return () => { + active = false; + }; + }, [signedMessage, route]); +}; + +export default useDeliveryStatus; diff --git a/wormhole-connect/src/hooks/usePorticoRelayerFee.ts b/wormhole-connect/src/hooks/usePorticoRelayerFee.ts index d1a07b414..4542188ca 100644 --- a/wormhole-connect/src/hooks/usePorticoRelayerFee.ts +++ b/wormhole-connect/src/hooks/usePorticoRelayerFee.ts @@ -56,15 +56,15 @@ export const usePorticoRelayerFee = (): void => { dispatch(setFetchingRelayerFee()); while (!cancelled) { try { - const fee = await RouteOperator.getRelayerFee( + const result = await RouteOperator.getRelayerFee( route, fromChain, toChain, token, destToken, ); - if (!cancelled) { - dispatch(setRelayerFee(fee.toString())); + if (!cancelled && result) { + dispatch(setRelayerFee(result.fee.toString())); } } catch { if (!cancelled) { diff --git a/wormhole-connect/src/icons/RouteIcons.tsx b/wormhole-connect/src/icons/RouteIcons.tsx index 133e03ab8..a50b5ae05 100644 --- a/wormhole-connect/src/icons/RouteIcons.tsx +++ b/wormhole-connect/src/icons/RouteIcons.tsx @@ -48,6 +48,12 @@ export const getIcon = (route: Route) => { case Route.wstETHBridge: { return WormholeIcon; } + case Route.NttManual: { + return WormholeIcon; + } + case Route.NttRelay: { + return WormholeIcon; + } default: { return noIcon; } diff --git a/wormhole-connect/src/icons/TokenIcons.tsx b/wormhole-connect/src/icons/TokenIcons.tsx index 5fa9ebecb..e5dcd5fc0 100644 --- a/wormhole-connect/src/icons/TokenIcons.tsx +++ b/wormhole-connect/src/icons/TokenIcons.tsx @@ -33,6 +33,7 @@ import KUJI from './Tokens/KUJI'; import KLAY from './Tokens/KLAY'; import PYTH from './Tokens/PYTH'; import INJ from './Tokens/INJ'; +import NTT from './Tokens/NTT'; const useStyles = makeStyles<{ size: number }>()((theme, { size }) => ({ container: { @@ -80,6 +81,7 @@ const iconMap: { [key in Icon]: React.JSX.Element } = { [Icon.PYTH]: PYTH(), [Icon.KLAY]: KLAY(), [Icon.INJ]: INJ(), + [Icon.NTT]: NTT(), }; function isBuiltinIcon(icon?: Icon | string): icon is Icon { diff --git a/wormhole-connect/src/icons/Tokens/NTT.tsx b/wormhole-connect/src/icons/Tokens/NTT.tsx new file mode 100644 index 000000000..5be40def2 --- /dev/null +++ b/wormhole-connect/src/icons/Tokens/NTT.tsx @@ -0,0 +1,84 @@ +import React from 'react'; + +function NTT() { + return ( + + + + + + + + + + + + + + + + + + + + + + + + + + ); +} + +export default NTT; diff --git a/wormhole-connect/src/routes/abstracts/routeAbstract.ts b/wormhole-connect/src/routes/abstracts/routeAbstract.ts index 15ebc0b24..fae0671ba 100644 --- a/wormhole-connect/src/routes/abstracts/routeAbstract.ts +++ b/wormhole-connect/src/routes/abstracts/routeAbstract.ts @@ -12,6 +12,7 @@ import { TransferDisplayData, TransferInfoBaseParams, TransferDestInfo, + RelayerFee, } from '../types'; import { ParsedRelayerMessage, ParsedMessage } from 'utils/sdk'; import { TokenPrices } from 'store/tokenPrices'; @@ -173,7 +174,7 @@ export abstract class RouteAbstract { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise; + ): Promise; abstract getForeignAsset( token: TokenId, diff --git a/wormhole-connect/src/routes/bridge/baseRoute.ts b/wormhole-connect/src/routes/bridge/baseRoute.ts index 63c123b83..b62c07964 100644 --- a/wormhole-connect/src/routes/bridge/baseRoute.ts +++ b/wormhole-connect/src/routes/bridge/baseRoute.ts @@ -47,6 +47,9 @@ export abstract class BaseRoute extends RouteAbstract { if (isTBTCToken(token) && token.nativeChain !== chainName) { return false; } + if (token.ntt) { + return false; + } return true; } @@ -60,6 +63,7 @@ export abstract class BaseRoute extends RouteAbstract { if (!token.tokenId) return false; if (destChain && isIlliquidDestToken(token, destChain)) return false; if (isTBTCToken(token)) return false; + if (token.ntt) return false; if (sourceToken) { const wrapped = getWrappedToken(sourceToken); return wrapped.key === token.key; @@ -297,4 +301,8 @@ export abstract class BaseRoute extends RouteAbstract { getMaxSendAmount(): number { return Infinity; } + + getMinSendAmount(routeOptions: any): number { + return 0; + } } diff --git a/wormhole-connect/src/routes/bridge/bridge.ts b/wormhole-connect/src/routes/bridge/bridge.ts index 9bd1a5e96..8b1e65e49 100644 --- a/wormhole-connect/src/routes/bridge/bridge.ts +++ b/wormhole-connect/src/routes/bridge/bridge.ts @@ -15,6 +15,7 @@ import { isSignedWormholeMessage, TokenTransferMessage, SignedTokenTransferMessage, + RelayerFee, } from '../types'; import { BaseRoute } from './baseRoute'; import { adaptParsedMessage } from '../utils'; @@ -60,6 +61,8 @@ export class BridgeRoute extends BaseRoute { ) return false; + if (sourceTokenConfig.ntt) return false; + if (!!sourceTokenConfig.tokenId && sourceToken === destToken) return true; if ( !sourceTokenConfig.tokenId && @@ -150,9 +153,6 @@ export class BridgeRoute extends BaseRoute { /** * These operations have to be implemented in subclasses. */ - getMinSendAmount(routeOptions: any): number { - return 0; - } async send( token: TokenId | 'native', @@ -240,8 +240,8 @@ export class BridgeRoute extends BaseRoute { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise { - return BigNumber.from(0); + ): Promise { + return null; } async getForeignAsset( diff --git a/wormhole-connect/src/routes/cctpManual/cctpManual.ts b/wormhole-connect/src/routes/cctpManual/cctpManual.ts index 7f3b6ed58..c5e6a8953 100644 --- a/wormhole-connect/src/routes/cctpManual/cctpManual.ts +++ b/wormhole-connect/src/routes/cctpManual/cctpManual.ts @@ -22,6 +22,7 @@ import { getAssociatedTokenAddress } from '@solana/spl-token'; import { BaseRoute } from '../bridge/baseRoute'; import { ManualCCTPMessage, + RelayerFee, SignedCCTPMessage, SignedMessage, TransferDestInfo, @@ -236,9 +237,6 @@ export class CCTPManualRoute extends BaseRoute { /** * These operations have to be implemented in subclasses. */ - getMinSendAmount(routeOptions: any): number { - return 0; - } async send( token: TokenId | 'native', @@ -377,8 +375,8 @@ export class CCTPManualRoute extends BaseRoute { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise { - return BigNumber.from(0); + ): Promise { + return null; } async getForeignAsset( diff --git a/wormhole-connect/src/routes/cctpRelay/cctpRelay.ts b/wormhole-connect/src/routes/cctpRelay/cctpRelay.ts index c119e7437..bbd779098 100644 --- a/wormhole-connect/src/routes/cctpRelay/cctpRelay.ts +++ b/wormhole-connect/src/routes/cctpRelay/cctpRelay.ts @@ -18,6 +18,7 @@ import { getTokenById, getDisplayName, calculateUSDPrice, + getWrappedTokenId, } from 'utils'; import { ParsedMessage, @@ -34,6 +35,7 @@ import { RelayCCTPMessage, TransferDestInfoBaseParams, TransferDestInfo, + RelayerFee, } from '../types'; import { toDecimals, toFixedDecimals } from '../../utils/balance'; import { RelayOptions } from '../relay'; @@ -205,12 +207,13 @@ export class CCTPRelayRoute extends CCTPManualRoute implements RelayAbstract { ): Promise { let relayerFee; try { - relayerFee = await this.getRelayerFee( + const result = await this.getRelayerFee( sourceChain, destChain, sourceToken, destToken, ); + relayerFee = result?.fee; } catch (e) { console.error(e); } @@ -477,7 +480,7 @@ export class CCTPRelayRoute extends CCTPManualRoute implements RelayAbstract { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise { + ): Promise { const tokenConfig = config.tokens[token]; if (!tokenConfig) throw new Error('could not get token config'); const tokenId = tokenConfig.tokenId; @@ -490,7 +493,7 @@ export class CCTPRelayRoute extends CCTPManualRoute implements RelayAbstract { chainContext.contracts.mustGetWormholeCircleRelayer(sourceChain); const destChainId = config.wh.toChainId(destChain); const fee = await circleRelayer.relayerFee(destChainId, tokenId?.address); - return fee; + return { fee, feeToken: tokenId || getWrappedTokenId(tokenConfig) }; } async getMessage( diff --git a/wormhole-connect/src/routes/cosmosGateway/cosmosGateway.ts b/wormhole-connect/src/routes/cosmosGateway/cosmosGateway.ts index 51a18ec47..c2b6028b5 100644 --- a/wormhole-connect/src/routes/cosmosGateway/cosmosGateway.ts +++ b/wormhole-connect/src/routes/cosmosGateway/cosmosGateway.ts @@ -35,6 +35,7 @@ import { TransferDestInfoBaseParams, TransferInfoBaseParams, TransferDestInfo, + RelayerFee, } from '../types'; import { BridgeRoute } from '../bridge/bridge'; import { fetchVaa } from '../../utils/vaa'; @@ -146,10 +147,6 @@ export class CosmosGatewayRoute extends BaseRoute { return config.wh.getForeignAsset(token, chain); } - getMinSendAmount(routeOptions: any): number { - return 0; - } - async send( token: TokenId | 'native', amount: string, @@ -287,8 +284,8 @@ export class CosmosGatewayRoute extends BaseRoute { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise { - return BigNumber.from(0); + ): Promise { + return null; } async isTransferCompleted( diff --git a/wormhole-connect/src/routes/hashflow/hashflow.ts b/wormhole-connect/src/routes/hashflow/hashflow.ts index 3f62a2afd..3f1400fb1 100644 --- a/wormhole-connect/src/routes/hashflow/hashflow.ts +++ b/wormhole-connect/src/routes/hashflow/hashflow.ts @@ -11,6 +11,7 @@ import { UnsignedMessage, SignedMessage, TransferDestInfo, + RelayerFee, } from '../types'; import { TransferDisplayData } from '../types'; import { RouteAbstract } from 'routes/abstracts'; @@ -137,7 +138,7 @@ export class HashflowRoute extends RouteAbstract { sourceChain: ChainName | ChainId, destChain: ChainName | ChainId, token: string, - ): Promise { + ): Promise { throw new Error('Method not implemented.'); } getForeignAsset( diff --git a/wormhole-connect/src/routes/ntt/errors.ts b/wormhole-connect/src/routes/ntt/errors.ts new file mode 100644 index 000000000..ac1f459d4 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/errors.ts @@ -0,0 +1,34 @@ +export class InboundQueuedTransferNotFoundError extends Error { + static MESSAGE = 'Inbound queued transfer not found'; + constructor() { + super(InboundQueuedTransferNotFoundError.MESSAGE); + } +} + +export class InboundQueuedTransferStillQueuedError extends Error { + static MESSAGE = 'Inbound queued transfer still queued'; + constructor() { + super(InboundQueuedTransferStillQueuedError.MESSAGE); + } +} + +export class NotEnoughCapacityError extends Error { + static MESSAGE = 'Not enough capacity'; + constructor() { + super(NotEnoughCapacityError.MESSAGE); + } +} + +export class ContractIsPausedError extends Error { + static MESSAGE = 'Contract is paused'; + constructor() { + super(ContractIsPausedError.MESSAGE); + } +} + +export class DestinationContractIsPausedError extends Error { + static MESSAGE = 'Destination contract is paused'; + constructor() { + super(DestinationContractIsPausedError.MESSAGE); + } +} diff --git a/wormhole-connect/src/routes/ntt/index.ts b/wormhole-connect/src/routes/ntt/index.ts new file mode 100644 index 000000000..52748d033 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/index.ts @@ -0,0 +1,6 @@ +export * from './nttBase'; +export * from './nttManual'; +export * from './nttRelay'; +export * from './errors'; +export * from './types'; +export * from './utils'; diff --git a/wormhole-connect/src/routes/ntt/nttBase.ts b/wormhole-connect/src/routes/ntt/nttBase.ts new file mode 100644 index 000000000..e092f7a4d --- /dev/null +++ b/wormhole-connect/src/routes/ntt/nttBase.ts @@ -0,0 +1,447 @@ +import { BigNumber } from 'ethers'; +import { + ChainId, + ChainName, + TokenId, +} from '@wormhole-foundation/wormhole-connect-sdk'; +import { Route, TokenConfig } from 'config/types'; +import { + SignedMessage, + UnsignedMessage, + UnsignedNttMessage, + SignedNttMessage, + TransferDestInfoBaseParams, + TransferDestInfo, + isSignedNttMessage, + RelayerFee, +} from '../types'; +import { fetchVaa } from 'utils/vaa'; +import { hexlify, parseUnits } from 'ethers/lib/utils.js'; +import { BaseRoute } from '../bridge'; +import { isEvmChain, solanaContext, toChainId, toChainName } from 'utils/sdk'; +import { + MAX_DECIMALS, + calculateUSDPrice, + getDisplayName, + getTokenById, + getTokenDecimals, + removeDust, + toNormalizedDecimals, +} from 'utils'; +import { getNttToken } from 'store/transferInput'; +import { getNttManager } from './platforms'; +import { InboundQueuedTransfer } from './types'; +import { + ContractIsPausedError, + DestinationContractIsPausedError, +} from './errors'; +import { WormholeTransceiver, getMessageEvm } from './platforms/evm'; +import { NttManagerSolana, getMessageSolana } from './platforms/solana'; +import { formatGasFee } from 'routes/utils'; +import { NO_INPUT } from 'utils/style'; +import { estimateAverageGasFee } from 'utils/gas'; +import config from 'config'; + +export abstract class NttBase extends BaseRoute { + isSupportedChain(chain: ChainName): boolean { + return isEvmChain(chain) || chain === 'solana'; + } + + async isSupportedSourceToken( + token?: TokenConfig, + destToken?: TokenConfig, + sourceChain?: ChainName | ChainId, + destChain?: ChainName | ChainId, + ): Promise { + if (!token || !sourceChain || !this.isSupportedToken(token, sourceChain)) { + return false; + } + if ( + destChain && + destToken && + !this.isSupportedToken(destToken, destChain) && + token.symbol === destToken.symbol + ) { + return false; + } + return true; + } + + async isSupportedDestToken( + token?: TokenConfig, + sourceToken?: TokenConfig, + sourceChain?: ChainName | ChainId, + destChain?: ChainName | ChainId, + ): Promise { + if (!token || !destChain || !this.isSupportedToken(token, destChain)) { + return false; + } + if ( + sourceChain && + sourceToken && + !this.isSupportedToken(sourceToken, sourceChain) && + token.symbol === sourceToken.symbol + ) { + return false; + } + return true; + } + + isSupportedToken(token: TokenConfig, chain: ChainName | ChainId): boolean { + return ( + this.isSupportedChain(token.nativeChain) && + !!token.ntt && + toChainName(chain) === token.nativeChain + ); + } + + async isRouteSupported( + sourceToken: string, + destToken: string, + amount: string, + sourceChain: ChainName | ChainId, + destChain: ChainName | ChainId, + ): Promise { + return await Promise.all([ + this.isSupportedChain(toChainName(sourceChain)), + this.isSupportedChain(toChainName(destChain)), + this.isSupportedSourceToken( + config.tokens[sourceToken], + config.tokens[destToken], + sourceChain, + destChain, + ), + this.isSupportedDestToken( + config.tokens[destToken], + config.tokens[sourceToken], + sourceChain, + destChain, + ), + ]).then((results) => results.every((result) => result)); + } + + async computeReceiveAmount( + sendAmount: number, + token: string, + destToken: string, + sendingChain: ChainName | undefined, + recipientChain: ChainName | undefined, + routeOptions: any, + ): Promise { + if (!sendAmount) return 0; + return sendAmount; + } + + async computeSendAmount( + receiveAmount: number | undefined, + routeOptions: any, + ): Promise { + if (!receiveAmount) return 0; + return receiveAmount; + } + + async validate( + token: TokenId | 'native', + amount: string, + sendingChain: ChainName | ChainId, + senderAddress: string, + recipientChain: ChainName | ChainId, + recipientAddress: string, + routeOptions: any, + ): Promise { + throw new Error('not implemented'); + } + + async estimateSendGas( + token: TokenId | 'native', + amount: string, + sendingChain: ChainName | ChainId, + senderAddress: string, + recipientChain: ChainName | ChainId, + recipientAddress: string, + routeOptions?: any, + ): Promise { + if (isEvmChain(sendingChain)) { + const gasLimit = this.TYPE === Route.NttManual ? 200_000 : 250_000; + return await estimateAverageGasFee(sendingChain, gasLimit); + } else if (toChainName(sendingChain) === 'solana') { + return BigNumber.from(10_000); + } + throw new Error('Unsupported chain'); + } + + async estimateClaimGas( + destChain: ChainName | ChainId, + signedMessage?: SignedMessage, + ): Promise { + if (this.TYPE === Route.NttRelay) { + // relayer pays claim gas + return BigNumber.from(0); + } + if (isEvmChain(destChain)) { + const gasLimit = 300_000; + return await estimateAverageGasFee(destChain, gasLimit); + } else if (toChainName(destChain) === 'solana') { + return BigNumber.from(65_000); // TODO: check this + } + throw new Error('Unsupported chain'); + } + + async send( + token: TokenId | 'native', + amount: string, + sendingChain: ChainName | ChainId, + senderAddress: string, + recipientChain: ChainName | ChainId, + recipientAddress: string, + destToken: string, + routeOptions: any, + ): Promise { + if (token === 'native') { + throw new Error('invalid token'); + } + const tokenConfig = getTokenById(token); + if (!tokenConfig?.ntt) { + throw new Error('invalid token'); + } + const destTokenConfig = config.tokens[destToken]; + if (!destTokenConfig?.ntt) { + throw new Error('invalid dest token'); + } + if ( + await getNttManager( + recipientChain, + destTokenConfig.ntt.nttManager, + ).isPaused() + ) { + throw new DestinationContractIsPausedError(); + } + const nttManager = getNttManager(sendingChain, tokenConfig.ntt.nttManager); + if (await nttManager.isPaused()) { + throw new ContractIsPausedError(); + } + const decimals = getTokenDecimals( + toChainId(sendingChain), + tokenConfig.tokenId, + ); + const sendAmount = removeDust(parseUnits(amount, decimals), decimals); + if (sendAmount.isZero()) { + throw new Error('Amount too low'); + } + const shouldSkipRelayerSend = this.TYPE !== Route.NttRelay; + return await nttManager.send( + token, + senderAddress, + recipientAddress, + sendAmount.toBigInt(), + recipientChain, + shouldSkipRelayerSend, + ); + } + + async redeem( + chain: ChainName | ChainId, + signedMessage: SignedMessage, + payer: string, + ): Promise { + if (!isSignedNttMessage(signedMessage)) { + throw new Error('Not a signed NttMessage'); + } + const { recipientNttManager, receivedTokenKey, vaa } = signedMessage; + const nttManager = getNttManager(chain, recipientNttManager); + if (await nttManager.isPaused()) { + throw new ContractIsPausedError(); + } + const nttConfig = config.tokens[receivedTokenKey]?.ntt; + if (!nttConfig) { + throw new Error('ntt config not found'); + } + if (isEvmChain(chain)) { + const transceiver = new WormholeTransceiver( + chain, + nttConfig.wormholeTransceiver, + ); + return await transceiver.receiveMessage(vaa, payer); + } + if (toChainName(chain) === 'solana') { + return await (nttManager as NttManagerSolana).receiveMessage(vaa, payer); + } + throw new Error('Unsupported chain'); + } + + async getRelayerFee( + sourceChain: ChainName | ChainId, + destChain: ChainName | ChainId, + token: string, + destToken: string, + ): Promise { + return null; + } + + async getCurrentOutboundCapacity( + chain: ChainId | ChainName, + nttManagerAddress: string, + ): Promise { + return await getNttManager( + chain, + nttManagerAddress, + ).getCurrentOutboundCapacity(); + } + + async getCurrentInboundCapacity( + chain: ChainId | ChainName, + nttManagerAddress: string, + fromChain: ChainId | ChainName, + ): Promise { + return await getNttManager( + chain, + nttManagerAddress, + ).getCurrentInboundCapacity(fromChain); + } + + async getRateLimitDuration( + chain: ChainId | ChainName, + nttManagerAddress: string, + ): Promise { + return await getNttManager(chain, nttManagerAddress).getRateLimitDuration(); + } + + async getInboundQueuedTransfer( + chain: ChainName | ChainId, + nttManagerAddress: string, + messageDigest: string, + ): Promise { + return await getNttManager( + chain, + nttManagerAddress, + ).getInboundQueuedTransfer(messageDigest); + } + + async completeInboundQueuedTransfer( + chain: ChainName | ChainId, + nttManagerAddress: string, + messageDigest: string, + recipientAddress: string, + payer: string, + ): Promise { + const nttManager = getNttManager(chain, nttManagerAddress); + if (await nttManager.isPaused()) { + throw new ContractIsPausedError(); + } + return await nttManager.completeInboundQueuedTransfer( + messageDigest, + recipientAddress, + payer, + ); + } + + async getForeignAsset( + token: TokenId, + chain: ChainName | ChainId, + ): Promise { + const tokenConfig = getTokenById(token); + if (!tokenConfig?.ntt) { + throw new Error('invalid token'); + } + const key = getNttToken(tokenConfig.ntt.groupId, chain); + return config.tokens[key]?.tokenId?.address || null; + } + + async getMessage( + tx: string, + chain: ChainName | ChainId, + ): Promise { + if (isEvmChain(chain)) { + return await getMessageEvm(tx, chain); + } + if (toChainName(chain) === 'solana') { + return await getMessageSolana(tx); + } + throw new Error('Unsupported chain'); + } + + async getSignedMessage( + unsigned: UnsignedNttMessage, + ): Promise { + const vaa = await fetchVaa(unsigned, true); + + if (!vaa) { + throw new Error('VAA not found'); + } + + return { + ...unsigned, + vaa: hexlify(vaa), + }; + } + + async tryFetchRedeemTx(txData: UnsignedMessage): Promise { + return undefined; + } + + async isTransferCompleted( + chain: ChainName | ChainId, + signedMessage: SignedNttMessage, + ): Promise { + if (!isSignedNttMessage(signedMessage)) { + throw new Error('Invalid signed message'); + } + const { recipientNttManager, messageDigest } = signedMessage; + const nttManager = getNttManager(chain, recipientNttManager); + return await nttManager.isTransferCompleted(messageDigest); + } + + async getTransferDestInfo( + params: T, + ): Promise { + const { + txData: { receivedTokenKey, amount, tokenDecimals, toChain }, + tokenPrices, + gasEstimate, + receiveTx, + } = params; + const token = config.tokens[receivedTokenKey]; + const formattedAmt = toNormalizedDecimals( + amount, + tokenDecimals, + MAX_DECIMALS, + ); + const result = { + route: this.TYPE, + displayData: [ + { + title: 'Amount', + value: `${formattedAmt} ${getDisplayName(token)}`, + valueUSD: calculateUSDPrice(formattedAmt, tokenPrices, token), + }, + ], + }; + if (this.TYPE === Route.NttManual) { + const { gasToken } = config.chains[toChain]!; + let gas = gasEstimate; + if (receiveTx) { + if (isEvmChain(toChain)) { + const gasFee = await config.wh.getTxGasFee(toChain, receiveTx); + if (gasFee) { + gas = formatGasFee(toChain, gasFee); + } + } else if (toChainName(toChain) === 'solana') { + const connection = solanaContext().connection; + if (!connection) throw new Error('Connection not found'); + const tx = await connection.getParsedTransaction(receiveTx); + if (tx?.meta?.fee) { + gas = formatGasFee(toChain, BigNumber.from(tx.meta.fee)); + } + } + } + result.displayData.push({ + title: receiveTx ? 'Gas fee' : 'Gas estimate', + value: gas + ? `${gas} ${getDisplayName(config.tokens[gasToken])}` + : NO_INPUT, + valueUSD: calculateUSDPrice(gas, tokenPrices, config.tokens[gasToken]), + }); + } + return result; + } +} diff --git a/wormhole-connect/src/routes/ntt/nttManual.ts b/wormhole-connect/src/routes/ntt/nttManual.ts new file mode 100644 index 000000000..ae6308334 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/nttManual.ts @@ -0,0 +1,8 @@ +import { Route } from 'config/types'; +import { NttBase } from './nttBase'; + +export class NttManual extends NttBase { + readonly NATIVE_GAS_DROPOFF_SUPPORTED: boolean = false; + readonly AUTOMATIC_DEPOSIT: boolean = false; + readonly TYPE: Route = Route.NttManual; +} diff --git a/wormhole-connect/src/routes/ntt/nttRelay.ts b/wormhole-connect/src/routes/ntt/nttRelay.ts new file mode 100644 index 000000000..e559da66a --- /dev/null +++ b/wormhole-connect/src/routes/ntt/nttRelay.ts @@ -0,0 +1,238 @@ +import { Route, TokenConfig } from 'config/types'; +import { BigNumber } from 'ethers'; +import { getNttManager } from './platforms'; +import { ChainName, ChainId } from '@wormhole-foundation/wormhole-connect-sdk'; +import { NttBase } from './nttBase'; +import { + RelayerFee, + TransferDisplayData, + TransferInfoBaseParams, + UnsignedMessage, + isUnsignedNttMessage, +} from 'routes/types'; +import { + MAX_DECIMALS, + calculateUSDPrice, + getDisplayName, + getTokenDecimals, + toNormalizedDecimals, +} from 'utils'; +import { + ParsedRelayerMessage, + isEvmChain, + toChainId, + toChainName, +} from 'utils/sdk'; +import { NO_INPUT } from 'utils/style'; +import { TokenPrices } from 'store/tokenPrices'; +import { toDecimals, toFixedDecimals } from 'utils/balance'; +import { NttManagerEvm, WormholeTransceiver } from './platforms/evm'; +import { NttQuoter } from './platforms/solana/nttQuoter'; +import config from 'config'; + +export class NttRelay extends NttBase { + readonly NATIVE_GAS_DROPOFF_SUPPORTED: boolean = false; + readonly AUTOMATIC_DEPOSIT: boolean = true; + readonly TYPE: Route = Route.NttRelay; + + async isRouteSupported( + sourceToken: string, + destToken: string, + amount: string, + sourceChain: ChainName | ChainId, + destChain: ChainName | ChainId, + ): Promise { + const nttConfig = config.tokens[sourceToken]?.ntt; + if (!nttConfig) { + return false; + } + if ( + !(await super.isRouteSupported( + sourceToken, + destToken, + amount, + sourceChain, + destChain, + )) + ) { + return false; + } + if (isEvmChain(sourceChain)) { + const transceiver = new WormholeTransceiver( + sourceChain, + nttConfig.wormholeTransceiver, + ); + return await Promise.all([ + transceiver.isWormholeRelayingEnabled(destChain), + transceiver.isSpecialRelayingEnabled(destChain), + ]).then((results) => results.some((r) => r)); + } + if (toChainName(sourceChain) === 'solana') { + if (!nttConfig.solanaQuoter) return false; + const quoter = new NttQuoter(nttConfig.solanaQuoter); + return await quoter.isRelayEnabled(destChain); + } + return false; + } + + async getRelayerFee( + sourceChain: ChainName | ChainId, + destChain: ChainName | ChainId, + token: string, + destToken: string, + ): Promise { + const nttConfig = config.tokens[token]?.ntt; + if (!nttConfig) { + throw new Error('invalid token'); + } + if (isEvmChain(sourceChain)) { + const nttManager = new NttManagerEvm(sourceChain, nttConfig.nttManager); + const deliveryPrice = await nttManager.quoteDeliveryPrice( + destChain, + nttConfig.wormholeTransceiver, + ); + return { fee: BigNumber.from(deliveryPrice), feeToken: 'native' }; + } + if (toChainName(sourceChain) === 'solana') { + if (!nttConfig.solanaQuoter) throw new Error('no solana quoter'); + const quoter = new NttQuoter(nttConfig.solanaQuoter); + const relayCost = await quoter.calcRelayCost(destChain); + return { fee: BigNumber.from(relayCost.toString()), feeToken: 'native' }; + } + throw new Error('unsupported chain'); + } + + async getPreview( + token: TokenConfig, + destToken: TokenConfig, + amount: number, + sendingChain: ChainName | ChainId, + receipientChain: ChainName | ChainId, + sendingGasEst: string, + claimingGasEst: string, + receiveAmount: string, + tokenPrices: TokenPrices, + routeOptions: { relayerFee: number }, + ): Promise { + const sendingChainName = toChainName(sendingChain); + const sourceGasToken = config.chains[sendingChainName]?.gasToken; + const sourceGasTokenSymbol = sourceGasToken + ? getDisplayName(config.tokens[sourceGasToken]) + : ''; + // Calculate the USD value of the gas + const sendingGasEstPrice = calculateUSDPrice( + sendingGasEst, + tokenPrices, + config.tokens[sourceGasToken || ''], + ); + const relayerFeePrice = calculateUSDPrice( + routeOptions.relayerFee, + tokenPrices, + config.tokens[sourceGasToken || ''], + ); + let totalFeesText = ''; + let totalFeesPrice = ''; + if ( + sendingGasEst && + sourceGasToken && + routeOptions.relayerFee !== undefined + ) { + const feeValue = + routeOptions.relayerFee + Number.parseFloat(sendingGasEst); + totalFeesText = toFixedDecimals(feeValue.toString(), 6); + totalFeesPrice = calculateUSDPrice( + feeValue, + tokenPrices, + config.tokens[sourceGasToken], + ); + } + return [ + { + title: 'Amount', + value: `${!isNaN(amount) ? amount : '0'} ${getDisplayName(destToken)}`, + valueUSD: calculateUSDPrice(amount, tokenPrices, destToken), + }, + { + title: 'Total fee estimates', + value: totalFeesText ? `${totalFeesText} ${sourceGasTokenSymbol}` : '', + valueUSD: totalFeesPrice ? `${totalFeesPrice || NO_INPUT}` : '', + rows: [ + { + title: 'Source chain gas estimate', + value: sendingGasEst + ? `~ ${sendingGasEst} ${sourceGasTokenSymbol}` + : 'Not available', + valueUSD: sendingGasEstPrice, + }, + { + title: 'Relayer fee', + value: routeOptions.relayerFee + ? `${routeOptions.relayerFee} ${sourceGasTokenSymbol}` + : NO_INPUT, + valueUSD: relayerFeePrice, + }, + ], + }, + ]; + } + + async getTransferSourceInfo( + params: T, + ): Promise { + const txData = params.txData as ParsedRelayerMessage; + const { tokenKey, amount, tokenDecimals, fromChain, gasFee, relayerFee } = + txData; + const tokenPrices = params.tokenPrices; + const formattedAmt = toNormalizedDecimals( + amount, + tokenDecimals, + MAX_DECIMALS, + ); + const { gasToken: sourceGasTokenKey } = config.chains[fromChain]!; + const sourceGasToken = config.tokens[sourceGasTokenKey]; + const decimals = getTokenDecimals( + toChainId(sourceGasToken.nativeChain), + 'native', + ); + const formattedGas = gasFee && toDecimals(gasFee, decimals, MAX_DECIMALS); + const formattedFee = + relayerFee && toDecimals(relayerFee, decimals, MAX_DECIMALS); + const token = config.tokens[tokenKey]; + + return [ + { + title: 'Amount', + value: `${formattedAmt} ${getDisplayName(token)}`, + valueUSD: calculateUSDPrice(formattedAmt, tokenPrices, token), + }, + { + title: 'Gas fee', + value: formattedGas + ? `${formattedGas} ${getDisplayName(sourceGasToken)}` + : NO_INPUT, + valueUSD: calculateUSDPrice(formattedGas, tokenPrices, sourceGasToken), + }, + { + title: 'Relayer fee', + value: formattedFee + ? `${formattedFee} ${getDisplayName(sourceGasToken)}` + : NO_INPUT, + valueUSD: calculateUSDPrice(formattedFee, tokenPrices, sourceGasToken), + }, + ]; + } + + async tryFetchRedeemTx(txData: UnsignedMessage): Promise { + if (!isUnsignedNttMessage(txData)) { + throw new Error('invalid txData'); + } + const { toChain, recipientNttManager, messageDigest } = txData; + const nttManager = getNttManager(toChain, recipientNttManager); + try { + return await nttManager.fetchRedeemTx(messageDigest); + } catch (e) { + console.error(e); + } + return undefined; + } +} diff --git a/wormhole-connect/src/routes/ntt/payloads/common.ts b/wormhole-connect/src/routes/ntt/payloads/common.ts new file mode 100644 index 000000000..4d5a5ace1 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/payloads/common.ts @@ -0,0 +1,120 @@ +import { BN } from '@coral-xyz/anchor'; + +export class TransceiverMessage { + static prefix: Buffer; + sourceNttManager: Buffer; + recipientNttManager: Buffer; + nttManagerPayload: NttManagerMessage; + transceiverPayload: Buffer; + + constructor( + sourceNttManager: Buffer, + recipientNttManager: Buffer, + nttManagerPayload: NttManagerMessage, + transceiverPayload: Buffer, + ) { + this.sourceNttManager = sourceNttManager; + this.recipientNttManager = recipientNttManager; + this.nttManagerPayload = nttManagerPayload; + this.transceiverPayload = transceiverPayload; + } + + static deserialize( + data: Buffer, + deserializer: (data: Buffer) => NttManagerMessage, + ): TransceiverMessage { + if (this.prefix === undefined) { + throw new Error('Unknown prefix.'); + } + const prefix = data.subarray(0, 4); + if (!prefix.equals(this.prefix)) { + throw new Error('Invalid prefix'); + } + const sourceNttManager = data.subarray(4, 36); + const recipientNttManager = data.subarray(36, 68); + const nttManagerPayloadLen = data.readUInt16BE(68); + const nttManagerPayload = deserializer( + data.subarray(70, 70 + nttManagerPayloadLen), + ); + const transceiverPayloadLen = data.readUInt16BE(70 + nttManagerPayloadLen); + const transceiverPayload = data.subarray( + 72 + nttManagerPayloadLen, + 72 + nttManagerPayloadLen + transceiverPayloadLen, + ); + return new TransceiverMessage( + sourceNttManager, + recipientNttManager, + nttManagerPayload, + transceiverPayload, + ); + } + + static serialize( + msg: TransceiverMessage, + serializer: (payload: NttManagerMessage) => Buffer, + ): Buffer { + const payload = serializer(msg.nttManagerPayload); + if (msg.sourceNttManager.length !== 32) { + throw new Error('sourceNttManager must be 32 bytes'); + } + if (msg.recipientNttManager.length !== 32) { + throw new Error('recipientNttManager must be 32 bytes'); + } + const payloadLen = new BN(payload.length).toBuffer('be', 2); + const transceiverPayloadLen = new BN( + msg.transceiverPayload.length, + ).toBuffer('be', 2); + const buffer = Buffer.concat([ + this.prefix, + msg.sourceNttManager, + msg.recipientNttManager, + payloadLen, + payload, + transceiverPayloadLen, + msg.transceiverPayload, + ]); + return buffer; + } +} + +export class NttManagerMessage { + id: Buffer; + sender: Buffer; + payload: A; + + constructor(id: Buffer, sender: Buffer, payload: A) { + if (id.length !== 32) { + throw new Error('id must be 32 bytes'); + } + if (sender.length !== 32) { + throw new Error('sender must be 32 bytes'); + } + this.id = id; + this.sender = sender; + this.payload = payload; + } + + static deserialize = ( + data: Buffer, + deserializer: (data: Buffer) => A, + ): NttManagerMessage => { + const id = data.subarray(0, 32); + const sender = data.subarray(32, 64); + const payloadLen = data.readUint16BE(64); + const payload = deserializer(data.subarray(66, 66 + payloadLen)); + return new NttManagerMessage(id, sender, payload); + }; + + static serialize = ( + msg: NttManagerMessage, + serializer: (payload: A) => Buffer, + ): Buffer => { + const payload = serializer(msg.payload); + return Buffer.concat([ + msg.id, + msg.sender, + new BN(payload.length).toBuffer('be', 2), + payload, + ]); + }; +} diff --git a/wormhole-connect/src/routes/ntt/payloads/transfers.ts b/wormhole-connect/src/routes/ntt/payloads/transfers.ts new file mode 100644 index 000000000..94cc6e63b --- /dev/null +++ b/wormhole-connect/src/routes/ntt/payloads/transfers.ts @@ -0,0 +1,50 @@ +import { TrimmedAmount } from './trimmedAmount'; + +export class NativeTokenTransfer { + static prefix = Buffer.from([0x99, 0x4e, 0x54, 0x54]); + trimmedAmount: TrimmedAmount; + sourceToken: Buffer; + recipientAddress: Buffer; + recipientChain: number; + + constructor( + sourceToken: Buffer, + amount: TrimmedAmount, + recipientChain: number, + recipientAddress: Buffer, + ) { + this.trimmedAmount = amount; + this.sourceToken = sourceToken; + this.recipientAddress = recipientAddress; + this.recipientChain = recipientChain; + } + + static deserialize = (data: Buffer): NativeTokenTransfer => { + const prefix = data.subarray(0, 4); + if (!prefix.equals(NativeTokenTransfer.prefix)) { + throw new Error('Invalid prefix'); + } + const amount = TrimmedAmount.deserialize(data.subarray(4, 13)); + const sourceToken = data.subarray(13, 45); + const recipientAddress = data.subarray(45, 77); + const recipientChain = data.readUInt16BE(77); + return new NativeTokenTransfer( + sourceToken, + amount, + recipientChain, + recipientAddress, + ); + }; + + static serialize = (msg: NativeTokenTransfer): Buffer => { + const buffer = Buffer.concat([ + NativeTokenTransfer.prefix, + TrimmedAmount.serialize(msg.trimmedAmount), + msg.sourceToken, + msg.recipientAddress, + ]); + const recipientChain = Buffer.alloc(2); + recipientChain.writeUInt16BE(msg.recipientChain, 0); + return Buffer.concat([buffer, recipientChain]); + }; +} diff --git a/wormhole-connect/src/routes/ntt/payloads/trimmedAmount.ts b/wormhole-connect/src/routes/ntt/payloads/trimmedAmount.ts new file mode 100644 index 000000000..b44904198 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/payloads/trimmedAmount.ts @@ -0,0 +1,22 @@ +export class TrimmedAmount { + amount: bigint; + decimals: number; + + constructor(amount: bigint, decimals: number) { + this.amount = amount; + this.decimals = decimals; + } + + static deserialize(data: Buffer): TrimmedAmount { + const decimals = data.readUInt8(0); + const amount = data.readBigUInt64BE(1); + return new TrimmedAmount(amount, decimals); + } + + static serialize(amount: TrimmedAmount): Buffer { + const buffer = Buffer.alloc(9); + buffer.writeUInt8(amount.decimals, 0); + buffer.writeBigUInt64BE(amount.amount, 1); + return buffer; + } +} diff --git a/wormhole-connect/src/routes/ntt/payloads/wormhole.ts b/wormhole-connect/src/routes/ntt/payloads/wormhole.ts new file mode 100644 index 000000000..b1ee02c71 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/payloads/wormhole.ts @@ -0,0 +1,5 @@ +import { TransceiverMessage } from './common'; + +export class WormholeTransceiverMessage extends TransceiverMessage { + static prefix = Buffer.from([0x99, 0x45, 0xff, 0x10]); +} diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager.ts b/wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager.ts new file mode 100644 index 000000000..2ddda09b0 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager.ts @@ -0,0 +1,1888 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { + FunctionFragment, + Result, + EventFragment, +} from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from './common'; + +export declare namespace TransceiverStructs { + export type NttManagerMessageStruct = { + id: BytesLike; + sender: BytesLike; + payload: BytesLike; + }; + + export type NttManagerMessageStructOutput = [string, string, string] & { + id: string; + sender: string; + payload: string; + }; + + export type TransceiverInstructionStruct = { + index: BigNumberish; + payload: BytesLike; + }; + + export type TransceiverInstructionStructOutput = [number, string] & { + index: number; + payload: string; + }; +} + +export declare namespace IRateLimiter { + export type RateLimitParamsStruct = { + limit: BigNumberish; + currentCapacity: BigNumberish; + lastTxTimestamp: BigNumberish; + }; + + export type RateLimitParamsStructOutput = [ + BigNumber, + BigNumber, + BigNumber, + ] & { + limit: BigNumber; + currentCapacity: BigNumber; + lastTxTimestamp: BigNumber; + }; + + export type InboundQueuedTransferStruct = { + amount: BigNumberish; + txTimestamp: BigNumberish; + recipient: string; + }; + + export type InboundQueuedTransferStructOutput = [ + BigNumber, + BigNumber, + string, + ] & { amount: BigNumber; txTimestamp: BigNumber; recipient: string }; + + export type OutboundQueuedTransferStruct = { + recipient: BytesLike; + amount: BigNumberish; + txTimestamp: BigNumberish; + recipientChain: BigNumberish; + sender: string; + transceiverInstructions: BytesLike; + }; + + export type OutboundQueuedTransferStructOutput = [ + string, + BigNumber, + BigNumber, + number, + string, + string, + ] & { + recipient: string; + amount: BigNumber; + txTimestamp: BigNumber; + recipientChain: number; + sender: string; + transceiverInstructions: string; + }; +} + +export declare namespace INttManagerState { + export type NttManagerPeerStruct = { + peerAddress: BytesLike; + tokenDecimals: BigNumberish; + }; + + export type NttManagerPeerStructOutput = [string, number] & { + peerAddress: string; + tokenDecimals: number; + }; +} + +export interface NttManagerInterface extends utils.Interface { + functions: { + 'attestationReceived(uint16,bytes32,(bytes32,bytes32,bytes))': FunctionFragment; + 'chainId()': FunctionFragment; + 'completeInboundQueuedTransfer(bytes32)': FunctionFragment; + 'completeOutboundQueuedTransfer(uint64)': FunctionFragment; + 'executeMsg(uint16,bytes32,(bytes32,bytes32,bytes))': FunctionFragment; + 'getCurrentInboundCapacity(uint16)': FunctionFragment; + 'getCurrentOutboundCapacity()': FunctionFragment; + 'getInboundLimitParams(uint16)': FunctionFragment; + 'getInboundQueuedTransfer(bytes32)': FunctionFragment; + 'getMigratesImmutables()': FunctionFragment; + 'getMode()': FunctionFragment; + 'getOutboundLimitParams()': FunctionFragment; + 'getOutboundQueuedTransfer(uint64)': FunctionFragment; + 'getPeer(uint16)': FunctionFragment; + 'getThreshold()': FunctionFragment; + 'getTransceivers()': FunctionFragment; + 'initialize()': FunctionFragment; + 'isMessageApproved(bytes32)': FunctionFragment; + 'isMessageExecuted(bytes32)': FunctionFragment; + 'isPaused()': FunctionFragment; + 'messageAttestations(bytes32)': FunctionFragment; + 'migrate()': FunctionFragment; + 'mode()': FunctionFragment; + 'nextMessageSequence()': FunctionFragment; + 'owner()': FunctionFragment; + 'pause()': FunctionFragment; + 'pauser()': FunctionFragment; + 'quoteDeliveryPrice(uint16,(uint8,bytes)[],address[])': FunctionFragment; + 'rateLimitDuration()': FunctionFragment; + 'removeTransceiver(address)': FunctionFragment; + 'setInboundLimit(uint256,uint16)': FunctionFragment; + 'setOutboundLimit(uint256)': FunctionFragment; + 'setPeer(uint16,bytes32,uint8,uint256)': FunctionFragment; + 'setThreshold(uint8)': FunctionFragment; + 'setTransceiver(address)': FunctionFragment; + 'token()': FunctionFragment; + 'tokenDecimals()': FunctionFragment; + 'tokenDecimals_()': FunctionFragment; + 'transceiverAttestedToMessage(bytes32,uint8)': FunctionFragment; + 'transfer(uint256,uint16,bytes32)': FunctionFragment; + 'transfer(uint256,uint16,bytes32,bool,bytes)': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'transferPauserCapability(address)': FunctionFragment; + 'upgrade(address)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'attestationReceived' + | 'chainId' + | 'completeInboundQueuedTransfer' + | 'completeOutboundQueuedTransfer' + | 'executeMsg' + | 'getCurrentInboundCapacity' + | 'getCurrentOutboundCapacity' + | 'getInboundLimitParams' + | 'getInboundQueuedTransfer' + | 'getMigratesImmutables' + | 'getMode' + | 'getOutboundLimitParams' + | 'getOutboundQueuedTransfer' + | 'getPeer' + | 'getThreshold' + | 'getTransceivers' + | 'initialize' + | 'isMessageApproved' + | 'isMessageExecuted' + | 'isPaused' + | 'messageAttestations' + | 'migrate' + | 'mode' + | 'nextMessageSequence' + | 'owner' + | 'pause' + | 'pauser' + | 'quoteDeliveryPrice' + | 'rateLimitDuration' + | 'removeTransceiver' + | 'setInboundLimit' + | 'setOutboundLimit' + | 'setPeer' + | 'setThreshold' + | 'setTransceiver' + | 'token' + | 'tokenDecimals' + | 'tokenDecimals_' + | 'transceiverAttestedToMessage' + | 'transfer(uint256,uint16,bytes32)' + | 'transfer(uint256,uint16,bytes32,bool,bytes)' + | 'transferOwnership' + | 'transferPauserCapability' + | 'upgrade', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'attestationReceived', + values: [ + BigNumberish, + BytesLike, + TransceiverStructs.NttManagerMessageStruct, + ], + ): string; + encodeFunctionData(functionFragment: 'chainId', values?: undefined): string; + encodeFunctionData( + functionFragment: 'completeInboundQueuedTransfer', + values: [BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'completeOutboundQueuedTransfer', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'executeMsg', + values: [ + BigNumberish, + BytesLike, + TransceiverStructs.NttManagerMessageStruct, + ], + ): 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?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getTransceivers', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'initialize', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'isMessageApproved', + values: [BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'isMessageExecuted', + values: [BytesLike], + ): string; + encodeFunctionData(functionFragment: 'isPaused', values?: undefined): string; + encodeFunctionData( + functionFragment: 'messageAttestations', + values: [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, + TransceiverStructs.TransceiverInstructionStruct[], + string[], + ], + ): string; + encodeFunctionData( + functionFragment: 'rateLimitDuration', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'removeTransceiver', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'setInboundLimit', + values: [BigNumberish, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setOutboundLimit', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setPeer', + values: [BigNumberish, BytesLike, BigNumberish, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setThreshold', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setTransceiver', + values: [string], + ): string; + encodeFunctionData(functionFragment: 'token', values?: undefined): string; + encodeFunctionData( + functionFragment: 'tokenDecimals', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'tokenDecimals_', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'transceiverAttestedToMessage', + values: [BytesLike, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'transfer(uint256,uint16,bytes32)', + values: [BigNumberish, BigNumberish, BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'transfer(uint256,uint16,bytes32,bool,bytes)', + values: [BigNumberish, BigNumberish, BytesLike, boolean, BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'transferOwnership', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'transferPauserCapability', + values: [string], + ): string; + encodeFunctionData(functionFragment: 'upgrade', values: [string]): string; + + decodeFunctionResult( + functionFragment: 'attestationReceived', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'chainId', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'completeInboundQueuedTransfer', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'completeOutboundQueuedTransfer', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'executeMsg', 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: 'getTransceivers', + 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: 'removeTransceiver', + 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: 'tokenDecimals_', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transceiverAttestedToMessage', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transfer(uint256,uint16,bytes32)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transfer(uint256,uint16,bytes32,bool,bytes)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferOwnership', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferPauserCapability', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'upgrade', data: BytesLike): Result; + + events: { + 'AdminChanged(address,address)': EventFragment; + 'BeaconUpgraded(address)': EventFragment; + 'InboundTransferQueued(bytes32)': EventFragment; + 'Initialized(uint64)': EventFragment; + 'MessageAlreadyExecuted(bytes32,bytes32)': EventFragment; + 'MessageAttestedTo(bytes32,address,uint8)': EventFragment; + 'NotPaused(bool)': EventFragment; + 'OutboundTransferQueued(uint64)': EventFragment; + 'OutboundTransferRateLimited(address,uint64,uint256,uint256)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'Paused(bool)': EventFragment; + 'PauserTransferred(address,address)': EventFragment; + 'PeerUpdated(uint16,bytes32,uint8,bytes32,uint8)': EventFragment; + 'ThresholdChanged(uint8,uint8)': EventFragment; + 'TransceiverAdded(address,uint256,uint8)': EventFragment; + 'TransceiverRemoved(address,uint8)': EventFragment; + 'TransferRedeemed(bytes32)': EventFragment; + 'TransferSent(bytes32,uint256,uint256,uint16,uint64)': EventFragment; + 'Upgraded(address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'AdminChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'BeaconUpgraded'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'InboundTransferQueued'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'MessageAlreadyExecuted'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'MessageAttestedTo'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'NotPaused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OutboundTransferQueued'): EventFragment; + getEvent( + nameOrSignatureOrTopic: 'OutboundTransferRateLimited', + ): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'PauserTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'PeerUpdated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ThresholdChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransceiverAdded'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransceiverRemoved'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransferRedeemed'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransferSent'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Upgraded'): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface InboundTransferQueuedEventObject { + digest: string; +} +export type InboundTransferQueuedEvent = TypedEvent< + [string], + InboundTransferQueuedEventObject +>; + +export type InboundTransferQueuedEventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: BigNumber; +} +export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface MessageAlreadyExecutedEventObject { + sourceNttManager: string; + msgHash: string; +} +export type MessageAlreadyExecutedEvent = TypedEvent< + [string, string], + MessageAlreadyExecutedEventObject +>; + +export type MessageAlreadyExecutedEventFilter = + TypedEventFilter; + +export interface MessageAttestedToEventObject { + digest: string; + transceiver: string; + index: number; +} +export type MessageAttestedToEvent = TypedEvent< + [string, string, number], + MessageAttestedToEventObject +>; + +export type MessageAttestedToEventFilter = + TypedEventFilter; + +export interface NotPausedEventObject { + notPaused: boolean; +} +export type NotPausedEvent = TypedEvent<[boolean], NotPausedEventObject>; + +export type NotPausedEventFilter = TypedEventFilter; + +export interface OutboundTransferQueuedEventObject { + queueSequence: BigNumber; +} +export type OutboundTransferQueuedEvent = TypedEvent< + [BigNumber], + OutboundTransferQueuedEventObject +>; + +export type OutboundTransferQueuedEventFilter = + TypedEventFilter; + +export interface OutboundTransferRateLimitedEventObject { + sender: string; + sequence: BigNumber; + amount: BigNumber; + currentCapacity: BigNumber; +} +export type OutboundTransferRateLimitedEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber], + OutboundTransferRateLimitedEventObject +>; + +export type OutboundTransferRateLimitedEventFilter = + TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface PausedEventObject { + paused: boolean; +} +export type PausedEvent = TypedEvent<[boolean], PausedEventObject>; + +export type PausedEventFilter = TypedEventFilter; + +export interface PauserTransferredEventObject { + oldPauser: string; + newPauser: string; +} +export type PauserTransferredEvent = TypedEvent< + [string, string], + PauserTransferredEventObject +>; + +export type PauserTransferredEventFilter = + TypedEventFilter; + +export interface PeerUpdatedEventObject { + chainId_: number; + oldPeerContract: string; + oldPeerDecimals: number; + peerContract: string; + peerDecimals: number; +} +export type PeerUpdatedEvent = TypedEvent< + [number, string, number, string, number], + PeerUpdatedEventObject +>; + +export type PeerUpdatedEventFilter = TypedEventFilter; + +export interface ThresholdChangedEventObject { + oldThreshold: number; + threshold: number; +} +export type ThresholdChangedEvent = TypedEvent< + [number, number], + ThresholdChangedEventObject +>; + +export type ThresholdChangedEventFilter = + TypedEventFilter; + +export interface TransceiverAddedEventObject { + transceiver: string; + transceiversNum: BigNumber; + threshold: number; +} +export type TransceiverAddedEvent = TypedEvent< + [string, BigNumber, number], + TransceiverAddedEventObject +>; + +export type TransceiverAddedEventFilter = + TypedEventFilter; + +export interface TransceiverRemovedEventObject { + transceiver: string; + threshold: number; +} +export type TransceiverRemovedEvent = TypedEvent< + [string, number], + TransceiverRemovedEventObject +>; + +export type TransceiverRemovedEventFilter = + TypedEventFilter; + +export interface TransferRedeemedEventObject { + digest: string; +} +export type TransferRedeemedEvent = TypedEvent< + [string], + TransferRedeemedEventObject +>; + +export type TransferRedeemedEventFilter = + TypedEventFilter; + +export interface TransferSentEventObject { + recipient: string; + amount: BigNumber; + fee: BigNumber; + recipientChain: number; + msgSequence: BigNumber; +} +export type TransferSentEvent = TypedEvent< + [string, BigNumber, BigNumber, number, BigNumber], + TransferSentEventObject +>; + +export type TransferSentEventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface NttManager extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: NttManagerInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined, + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter, + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter, + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + chainId(overrides?: CallOverrides): Promise<[number]>; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + getCurrentOutboundCapacity(overrides?: CallOverrides): Promise<[BigNumber]>; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise<[IRateLimiter.RateLimitParamsStructOutput]>; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise<[IRateLimiter.InboundQueuedTransferStructOutput]>; + + getMigratesImmutables(overrides?: CallOverrides): Promise<[boolean]>; + + getMode(overrides?: CallOverrides): Promise<[number]>; + + getOutboundLimitParams( + overrides?: CallOverrides, + ): Promise<[IRateLimiter.RateLimitParamsStructOutput]>; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise<[IRateLimiter.OutboundQueuedTransferStructOutput]>; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise<[INttManagerState.NttManagerPeerStructOutput]>; + + getThreshold(overrides?: CallOverrides): Promise<[number]>; + + getTransceivers( + overrides?: CallOverrides, + ): Promise<[string[]] & { result: string[] }>; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isPaused(overrides?: CallOverrides): Promise<[boolean]>; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise<[number] & { count: number }>; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + mode(overrides?: CallOverrides): Promise<[number]>; + + nextMessageSequence(overrides?: CallOverrides): Promise<[BigNumber]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + pauser(overrides?: CallOverrides): Promise<[string]>; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], + enabledTransceivers: string[], + overrides?: CallOverrides, + ): Promise<[BigNumber[], BigNumber]>; + + rateLimitDuration(overrides?: CallOverrides): Promise<[BigNumber]>; + + removeTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + token(overrides?: CallOverrides): Promise<[string]>; + + tokenDecimals(overrides?: CallOverrides): Promise<[number]>; + + tokenDecimals_(overrides?: CallOverrides): Promise<[number]>; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; + + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + chainId(overrides?: CallOverrides): Promise; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getMode(overrides?: CallOverrides): Promise; + + getOutboundLimitParams( + overrides?: CallOverrides, + ): Promise; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getThreshold(overrides?: CallOverrides): Promise; + + getTransceivers(overrides?: CallOverrides): Promise; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + mode(overrides?: CallOverrides): Promise; + + nextMessageSequence(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], + enabledTransceivers: string[], + overrides?: CallOverrides, + ): Promise<[BigNumber[], BigNumber]>; + + rateLimitDuration(overrides?: CallOverrides): Promise; + + removeTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + token(overrides?: CallOverrides): Promise; + + tokenDecimals(overrides?: CallOverrides): Promise; + + tokenDecimals_(overrides?: CallOverrides): Promise; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + callStatic: { + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: CallOverrides, + ): Promise; + + chainId(overrides?: CallOverrides): Promise; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: CallOverrides, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getMode(overrides?: CallOverrides): Promise; + + getOutboundLimitParams( + overrides?: CallOverrides, + ): Promise; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getThreshold(overrides?: CallOverrides): Promise; + + getTransceivers(overrides?: CallOverrides): Promise; + + initialize(overrides?: CallOverrides): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + migrate(overrides?: CallOverrides): Promise; + + mode(overrides?: CallOverrides): Promise; + + nextMessageSequence(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: CallOverrides): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], + enabledTransceivers: string[], + overrides?: CallOverrides, + ): Promise<[BigNumber[], BigNumber]>; + + rateLimitDuration(overrides?: CallOverrides): Promise; + + removeTransceiver( + transceiver: string, + overrides?: CallOverrides, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: CallOverrides, + ): Promise; + + token(overrides?: CallOverrides): Promise; + + tokenDecimals(overrides?: CallOverrides): Promise; + + tokenDecimals_(overrides?: CallOverrides): Promise; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: CallOverrides, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: CallOverrides, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: CallOverrides, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: CallOverrides, + ): Promise; + }; + + filters: { + 'AdminChanged(address,address)'( + previousAdmin?: null, + newAdmin?: null, + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null, + ): AdminChangedEventFilter; + + 'BeaconUpgraded(address)'( + beacon?: string | null, + ): BeaconUpgradedEventFilter; + BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter; + + 'InboundTransferQueued(bytes32)'( + digest?: null, + ): InboundTransferQueuedEventFilter; + InboundTransferQueued(digest?: null): InboundTransferQueuedEventFilter; + + 'Initialized(uint64)'(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + 'MessageAlreadyExecuted(bytes32,bytes32)'( + sourceNttManager?: BytesLike | null, + msgHash?: BytesLike | null, + ): MessageAlreadyExecutedEventFilter; + MessageAlreadyExecuted( + sourceNttManager?: BytesLike | null, + msgHash?: BytesLike | null, + ): MessageAlreadyExecutedEventFilter; + + 'MessageAttestedTo(bytes32,address,uint8)'( + digest?: null, + transceiver?: null, + index?: null, + ): MessageAttestedToEventFilter; + MessageAttestedTo( + digest?: null, + transceiver?: null, + index?: null, + ): MessageAttestedToEventFilter; + + 'NotPaused(bool)'(notPaused?: null): NotPausedEventFilter; + NotPaused(notPaused?: null): NotPausedEventFilter; + + 'OutboundTransferQueued(uint64)'( + queueSequence?: null, + ): OutboundTransferQueuedEventFilter; + OutboundTransferQueued( + queueSequence?: null, + ): OutboundTransferQueuedEventFilter; + + 'OutboundTransferRateLimited(address,uint64,uint256,uint256)'( + sender?: string | null, + sequence?: null, + amount?: null, + currentCapacity?: null, + ): OutboundTransferRateLimitedEventFilter; + OutboundTransferRateLimited( + sender?: string | null, + sequence?: null, + amount?: null, + currentCapacity?: null, + ): OutboundTransferRateLimitedEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + + 'Paused(bool)'(paused?: null): PausedEventFilter; + Paused(paused?: null): PausedEventFilter; + + 'PauserTransferred(address,address)'( + oldPauser?: string | null, + newPauser?: string | null, + ): PauserTransferredEventFilter; + PauserTransferred( + oldPauser?: string | null, + newPauser?: string | null, + ): PauserTransferredEventFilter; + + 'PeerUpdated(uint16,bytes32,uint8,bytes32,uint8)'( + chainId_?: BigNumberish | null, + oldPeerContract?: null, + oldPeerDecimals?: null, + peerContract?: null, + peerDecimals?: null, + ): PeerUpdatedEventFilter; + PeerUpdated( + chainId_?: BigNumberish | null, + oldPeerContract?: null, + oldPeerDecimals?: null, + peerContract?: null, + peerDecimals?: null, + ): PeerUpdatedEventFilter; + + 'ThresholdChanged(uint8,uint8)'( + oldThreshold?: null, + threshold?: null, + ): ThresholdChangedEventFilter; + ThresholdChanged( + oldThreshold?: null, + threshold?: null, + ): ThresholdChangedEventFilter; + + 'TransceiverAdded(address,uint256,uint8)'( + transceiver?: null, + transceiversNum?: null, + threshold?: null, + ): TransceiverAddedEventFilter; + TransceiverAdded( + transceiver?: null, + transceiversNum?: null, + threshold?: null, + ): TransceiverAddedEventFilter; + + 'TransceiverRemoved(address,uint8)'( + transceiver?: null, + threshold?: null, + ): TransceiverRemovedEventFilter; + TransceiverRemoved( + transceiver?: null, + threshold?: null, + ): TransceiverRemovedEventFilter; + + 'TransferRedeemed(bytes32)'( + digest?: BytesLike | null, + ): TransferRedeemedEventFilter; + TransferRedeemed(digest?: BytesLike | null): TransferRedeemedEventFilter; + + 'TransferSent(bytes32,uint256,uint256,uint16,uint64)'( + recipient?: null, + amount?: null, + fee?: null, + recipientChain?: null, + msgSequence?: null, + ): TransferSentEventFilter; + TransferSent( + recipient?: null, + amount?: null, + fee?: null, + recipientChain?: null, + msgSequence?: null, + ): TransferSentEventFilter; + + 'Upgraded(address)'(implementation?: string | null): UpgradedEventFilter; + Upgraded(implementation?: string | null): UpgradedEventFilter; + }; + + estimateGas: { + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + chainId(overrides?: CallOverrides): Promise; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getMode(overrides?: CallOverrides): Promise; + + getOutboundLimitParams(overrides?: CallOverrides): Promise; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getThreshold(overrides?: CallOverrides): Promise; + + getTransceivers(overrides?: CallOverrides): Promise; + + initialize(overrides?: Overrides & { from?: string }): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + migrate(overrides?: Overrides & { from?: string }): Promise; + + mode(overrides?: CallOverrides): Promise; + + nextMessageSequence(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: string }): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], + enabledTransceivers: string[], + overrides?: CallOverrides, + ): Promise; + + rateLimitDuration(overrides?: CallOverrides): Promise; + + removeTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + token(overrides?: CallOverrides): Promise; + + tokenDecimals(overrides?: CallOverrides): Promise; + + tokenDecimals_(overrides?: CallOverrides): Promise; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; + + populateTransaction: { + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + chainId(overrides?: CallOverrides): Promise; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getCurrentOutboundCapacity( + overrides?: CallOverrides, + ): Promise; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + getMigratesImmutables( + overrides?: CallOverrides, + ): Promise; + + getMode(overrides?: CallOverrides): Promise; + + getOutboundLimitParams( + overrides?: CallOverrides, + ): Promise; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getThreshold(overrides?: CallOverrides): Promise; + + getTransceivers(overrides?: CallOverrides): Promise; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + mode(overrides?: CallOverrides): Promise; + + nextMessageSequence( + overrides?: CallOverrides, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], + enabledTransceivers: string[], + overrides?: CallOverrides, + ): Promise; + + rateLimitDuration(overrides?: CallOverrides): Promise; + + removeTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + token(overrides?: CallOverrides): Promise; + + tokenDecimals(overrides?: CallOverrides): Promise; + + tokenDecimals_(overrides?: CallOverrides): Promise; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; +} diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager__factory.ts b/wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager__factory.ts new file mode 100644 index 000000000..e670e34e0 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager__factory.ts @@ -0,0 +1,1858 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { + Signer, + utils, + Contract, + ContractFactory, + BigNumberish, + Overrides, +} from 'ethers'; +import type { Provider, TransactionRequest } from '@ethersproject/providers'; +import type { NttManager, NttManagerInterface } from './NttManager'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'enum INttManager.Mode', + name: '_mode', + type: 'uint8', + }, + { + internalType: 'uint16', + name: '_chainId', + type: 'uint16', + }, + { + internalType: 'uint64', + name: '_rateLimitDuration', + type: 'uint64', + }, + { + internalType: 'bool', + name: '_skipRateLimiting', + type: 'bool', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'AmountTooLarge', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'burnAmount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'balanceDiff', + type: 'uint256', + }, + ], + name: 'BurnAmountDifferentThanBalanceDiff', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'caller', + type: 'address', + }, + ], + name: 'CallerNotTransceiver', + type: 'error', + }, + { + inputs: [ + { + internalType: 'TrimmedAmount', + name: 'newCurrentCapacity', + type: 'uint72', + }, + { + internalType: 'TrimmedAmount', + name: 'newLimit', + type: 'uint72', + }, + ], + name: 'CapacityCannotExceedLimit', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'requiredPayment', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'providedPayment', + type: 'uint256', + }, + ], + name: 'DeliveryPaymentTooLow', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'DisabledTransceiver', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'InboundQueuedTransferNotFound', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + internalType: 'uint256', + name: 'transferTimestamp', + type: 'uint256', + }, + ], + name: 'InboundQueuedTransferStillQueued', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'evmChainId', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'blockChainId', + type: 'uint256', + }, + ], + name: 'InvalidFork', + type: 'error', + }, + { + inputs: [], + name: 'InvalidInitialization', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint8', + name: 'mode', + type: 'uint8', + }, + ], + name: 'InvalidMode', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'InvalidPauser', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerAddress', + type: 'bytes32', + }, + ], + name: 'InvalidPeer', + type: 'error', + }, + { + inputs: [], + name: 'InvalidPeerChainIdZero', + type: 'error', + }, + { + inputs: [], + name: 'InvalidPeerDecimals', + type: 'error', + }, + { + inputs: [], + name: 'InvalidPeerZeroAddress', + type: 'error', + }, + { + inputs: [], + name: 'InvalidRecipient', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'targetChain', + type: 'uint16', + }, + { + internalType: 'uint16', + name: 'thisChain', + type: 'uint16', + }, + ], + name: 'InvalidTargetChain', + type: 'error', + }, + { + inputs: [], + name: 'InvalidTransceiverZeroAddress', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'msgHash', + type: 'bytes32', + }, + ], + name: 'MessageNotApproved', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'NonRegisteredTransceiver', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: '', + type: 'bytes32', + }, + ], + name: 'NotAnEvmAddress', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'currentCapacity', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'NotEnoughCapacity', + type: 'error', + }, + { + inputs: [], + name: 'NotInitializing', + type: 'error', + }, + { + inputs: [], + name: 'NotMigrating', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint8', + name: 'decimals', + type: 'uint8', + }, + { + internalType: 'uint8', + name: 'decimalsOther', + type: 'uint8', + }, + ], + name: 'NumberOfDecimalsNotEqual', + type: 'error', + }, + { + inputs: [], + name: 'OnlyDelegateCall', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint64', + name: 'queueSequence', + type: 'uint64', + }, + ], + name: 'OutboundQueuedTransferNotFound', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint64', + name: 'queueSequence', + type: 'uint64', + }, + { + internalType: 'uint256', + name: 'transferTimestamp', + type: 'uint256', + }, + ], + name: 'OutboundQueuedTransferStillQueued', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'OwnableInvalidOwner', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'OwnableUnauthorizedAccount', + type: 'error', + }, + { + inputs: [], + name: 'ReentrancyGuardReentrantCall', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'refundAmount', + type: 'uint256', + }, + ], + name: 'RefundFailed', + type: 'error', + }, + { + inputs: [], + name: 'RequireContractIsNotPaused', + type: 'error', + }, + { + inputs: [], + name: 'RequireContractIsPaused', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'retrieved', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'registered', + type: 'uint256', + }, + ], + name: 'RetrievedIncorrectRegisteredTransceivers', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'threshold', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'transceivers', + type: 'uint256', + }, + ], + name: 'ThresholdTooHigh', + type: 'error', + }, + { + inputs: [], + name: 'TooManyTransceivers', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'nttManagerMessageHash', + type: 'bytes32', + }, + ], + name: 'TransceiverAlreadyAttestedToMessage', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'TransceiverAlreadyEnabled', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'dust', + type: 'uint256', + }, + ], + name: 'TransferAmountHasDust', + type: 'error', + }, + { + inputs: [], + name: 'UndefinedRateLimiting', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'expectedOwner', + type: 'address', + }, + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'UnexpectedDeployer', + type: 'error', + }, + { + inputs: [], + name: 'ZeroAmount', + type: 'error', + }, + { + inputs: [], + name: 'ZeroThreshold', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'previousAdmin', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'newAdmin', + type: 'address', + }, + ], + name: 'AdminChanged', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'beacon', + type: 'address', + }, + ], + name: 'BeaconUpgraded', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'InboundTransferQueued', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint64', + name: 'version', + type: 'uint64', + }, + ], + name: 'Initialized', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'bytes32', + name: 'sourceNttManager', + type: 'bytes32', + }, + { + indexed: true, + internalType: 'bytes32', + name: 'msgHash', + type: 'bytes32', + }, + ], + name: 'MessageAlreadyExecuted', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + { + indexed: false, + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + ], + name: 'MessageAttestedTo', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bool', + name: 'notPaused', + type: 'bool', + }, + ], + name: 'NotPaused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint64', + name: 'queueSequence', + type: 'uint64', + }, + ], + name: 'OutboundTransferQueued', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'sender', + type: 'address', + }, + { + indexed: false, + internalType: 'uint64', + name: 'sequence', + type: 'uint64', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'currentCapacity', + type: 'uint256', + }, + ], + name: 'OutboundTransferRateLimited', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'previousOwner', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnershipTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bool', + name: 'paused', + type: 'bool', + }, + ], + name: 'Paused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'oldPauser', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newPauser', + type: 'address', + }, + ], + name: 'PauserTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'oldPeerContract', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint8', + name: 'oldPeerDecimals', + type: 'uint8', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'peerContract', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint8', + name: 'peerDecimals', + type: 'uint8', + }, + ], + name: 'PeerUpdated', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint8', + name: 'oldThreshold', + type: 'uint8', + }, + { + indexed: false, + internalType: 'uint8', + name: 'threshold', + type: 'uint8', + }, + ], + name: 'ThresholdChanged', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'transceiversNum', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint8', + name: 'threshold', + type: 'uint8', + }, + ], + name: 'TransceiverAdded', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + { + indexed: false, + internalType: 'uint8', + name: 'threshold', + type: 'uint8', + }, + ], + name: 'TransceiverRemoved', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'TransferRedeemed', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'recipient', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'fee', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + indexed: false, + internalType: 'uint64', + name: 'msgSequence', + type: 'uint64', + }, + ], + name: 'TransferSent', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'implementation', + type: 'address', + }, + ], + name: 'Upgraded', + type: 'event', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'sourceChainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'sourceNttManagerAddress', + type: 'bytes32', + }, + { + components: [ + { + internalType: 'bytes32', + name: 'id', + type: 'bytes32', + }, + { + internalType: 'bytes32', + name: 'sender', + type: 'bytes32', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.NttManagerMessage', + name: 'payload', + type: 'tuple', + }, + ], + name: 'attestationReceived', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'chainId', + outputs: [ + { + internalType: 'uint16', + name: '', + type: 'uint16', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'completeInboundQueuedTransfer', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint64', + name: 'messageSequence', + type: 'uint64', + }, + ], + name: 'completeOutboundQueuedTransfer', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'sourceChainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'sourceNttManagerAddress', + type: 'bytes32', + }, + { + components: [ + { + internalType: 'bytes32', + name: 'id', + type: 'bytes32', + }, + { + internalType: 'bytes32', + name: 'sender', + type: 'bytes32', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.NttManagerMessage', + name: 'message', + type: 'tuple', + }, + ], + name: 'executeMsg', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + ], + name: 'getCurrentInboundCapacity', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getCurrentOutboundCapacity', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + ], + name: 'getInboundLimitParams', + outputs: [ + { + components: [ + { + internalType: 'TrimmedAmount', + name: 'limit', + type: 'uint72', + }, + { + internalType: 'TrimmedAmount', + name: 'currentCapacity', + type: 'uint72', + }, + { + internalType: 'uint64', + name: 'lastTxTimestamp', + type: 'uint64', + }, + ], + internalType: 'struct IRateLimiter.RateLimitParams', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'getInboundQueuedTransfer', + outputs: [ + { + components: [ + { + internalType: 'TrimmedAmount', + name: 'amount', + type: 'uint72', + }, + { + internalType: 'uint64', + name: 'txTimestamp', + type: 'uint64', + }, + { + internalType: 'address', + name: 'recipient', + type: 'address', + }, + ], + internalType: 'struct IRateLimiter.InboundQueuedTransfer', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getMigratesImmutables', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getMode', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getOutboundLimitParams', + outputs: [ + { + components: [ + { + internalType: 'TrimmedAmount', + name: 'limit', + type: 'uint72', + }, + { + internalType: 'TrimmedAmount', + name: 'currentCapacity', + type: 'uint72', + }, + { + internalType: 'uint64', + name: 'lastTxTimestamp', + type: 'uint64', + }, + ], + internalType: 'struct IRateLimiter.RateLimitParams', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint64', + name: 'queueSequence', + type: 'uint64', + }, + ], + name: 'getOutboundQueuedTransfer', + outputs: [ + { + components: [ + { + internalType: 'bytes32', + name: 'recipient', + type: 'bytes32', + }, + { + internalType: 'TrimmedAmount', + name: 'amount', + type: 'uint72', + }, + { + internalType: 'uint64', + name: 'txTimestamp', + type: 'uint64', + }, + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + internalType: 'address', + name: 'sender', + type: 'address', + }, + { + internalType: 'bytes', + name: 'transceiverInstructions', + type: 'bytes', + }, + ], + internalType: 'struct IRateLimiter.OutboundQueuedTransfer', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + ], + name: 'getPeer', + outputs: [ + { + components: [ + { + internalType: 'bytes32', + name: 'peerAddress', + type: 'bytes32', + }, + { + internalType: 'uint8', + name: 'tokenDecimals', + type: 'uint8', + }, + ], + internalType: 'struct INttManagerState.NttManagerPeer', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getThreshold', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getTransceivers', + outputs: [ + { + internalType: 'address[]', + name: 'result', + type: 'address[]', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [], + name: 'initialize', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'isMessageApproved', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'isMessageExecuted', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'isPaused', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'messageAttestations', + outputs: [ + { + internalType: 'uint8', + name: 'count', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'migrate', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'mode', + outputs: [ + { + internalType: 'enum INttManager.Mode', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'nextMessageSequence', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'pause', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'pauser', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + components: [ + { + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.TransceiverInstruction[]', + name: 'transceiverInstructions', + type: 'tuple[]', + }, + { + internalType: 'address[]', + name: 'enabledTransceivers', + type: 'address[]', + }, + ], + name: 'quoteDeliveryPrice', + outputs: [ + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'rateLimitDuration', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'removeTransceiver', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'limit', + type: 'uint256', + }, + { + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + ], + name: 'setInboundLimit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'limit', + type: 'uint256', + }, + ], + name: 'setOutboundLimit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'peerChainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerContract', + type: 'bytes32', + }, + { + internalType: 'uint8', + name: 'decimals', + type: 'uint8', + }, + { + internalType: 'uint256', + name: 'inboundLimit', + type: 'uint256', + }, + ], + name: 'setPeer', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint8', + name: 'threshold', + type: 'uint8', + }, + ], + name: 'setThreshold', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'setTransceiver', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'token', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'tokenDecimals', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'tokenDecimals_', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + ], + name: 'transceiverAttestedToMessage', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'recipient', + type: 'bytes32', + }, + ], + name: 'transfer', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'recipient', + type: 'bytes32', + }, + { + internalType: 'bool', + name: 'shouldQueue', + type: 'bool', + }, + { + internalType: 'bytes', + name: 'transceiverInstructions', + type: 'bytes', + }, + ], + name: 'transfer', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newPauser', + type: 'address', + }, + ], + name: 'transferPauserCapability', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newImplementation', + type: 'address', + }, + ], + name: 'upgrade', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, +] as const; + +const _bytecode = + '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$93083e246e55d56d98f3df2872cd16bfd0$__9063b3f07bbd906117cf9087908690600401615ab4565b602060405180830381865af41580156117ec573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118109190615a46565b905061183d8161181e612b94565b336000908152602091909152604090205462010000900460ff16611177565b1561185e57604051631089c4a160e11b815260048101829052602401610fd4565b61186881336132f7565b611871816109aa565b1561188157611881848484611ae0565b50505050565b61188f6121b5565b61189881613398565b60006118a2612678565b905060006118ae6126a6565b54825460ff61010090920482169250168110156118d357815460ff191660ff82161782555b8154604080516001600160a01b038616815260ff90921660208301527f697a3853515b88013ad432f29f53d406debc9509ed6d9313dcfe115250fcd18f91015b60405180910390a1505050565b600061192a612187565b546001600160a01b0316919050565b60006119436127ed565b61194b611998565b15611969576040516309e3d0f360e11b815260040160405180910390fd5b6119768686868686612bc2565b905061198f600160008051602061612f83398151915255565b95945050505050565b6000806119a3613660565b5460021492915050565b60606119b761368e565b805480602002602001604051908101604052809291908181526020018280548015611a0b57602002820191906000526020600020905b81546001600160a01b031681526001909101906020018083116119ed575b5050505050905090565b6040805180820190915260008082526020820152611a3161275e565b61ffff909216600090815260209283526040908190208151808301909252805482526001015460ff16928101929092525090565b6040805160608101825260008082526020820181905291810191909152611a8a6136bb565b61ffff9290921660009081526020928352604090819020815160608101835290546001600160481b038082168352600160481b82041694820194909452600160901b9093046001600160401b0316908301525090565b611b097f00000000000000000000000000000000000000000000000000000000000000006136e9565b60405163b3f07bbd60e01b815260009073__$93083e246e55d56d98f3df2872cd16bfd0$__9063b3f07bbd90611b459087908690600401615ab4565b602060405180830381865af4158015611b62573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b869190615a46565b9050611b91816109aa565b611bb157604051630451c4fb60e41b815260048101829052602401610fd4565b6000611bbc82613712565b90508015611bf857604051829085907f4069dff8c9df7e38d2867c0910bd96fd61787695e5380281148c04932d02bef290600090a35050505050565b6040808401519051635399ded560e11b815260009173__$93083e246e55d56d98f3df2872cd16bfd0$__9163a733bdaa91611c3591600401615ad1565b608060405180830381865af4158015611c52573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611c769190615ae4565b90507f000000000000000000000000000000000000000000000000000000000000000061ffff16816060015161ffff1614611cf9576060810151604051631ee5902560e11b815261ffff91821660048201527f00000000000000000000000000000000000000000000000000000000000000009091166024820152604401610fd4565b6000611d877f00000000000000000000000000000000000000000000000000000000000000007f0000000000000000000000000000000000000000000000000000000000000000611d807f000000000000000000000000000000000000000000000000000000000000000086600001516001600160481b031661211490919063ffffffff16565b91906122f5565b90506000611d988360400151613753565b90506000611da6838a61377f565b90508015611dc457611db98684846137ce565b505050505050505050565b50611dcf82896138a7565b611dd88261390d565b611de3858284612853565b5050505050505050565b611df56121b5565b8060ff16600003611e195760405163831761d760e01b815260040160405180910390fd5b6000611e23612678565b805460ff84811660ff19831617835591925016611e3e61395d565b6040805160ff8084168252851660208201527f2a855b929b9a53c6fb5b5ed248b27e502b709c088e036a5aa17620c8fc5085a99101611913565b6000610cd1612678565b611e8a6121b5565b611e93816139fe565b6000611e9d613a39565b9050611ea7613a67565b60005b8154811015611f4057818181548110611ec557611ec56159f1565b600091825260209091200154604051632c7b84dd60e11b81526001600160a01b038581166004830152909116906358f709ba90602401600060405180830381600087803b158015611f1557600080fd5b505af1158015611f29573d6000803e3d6000fd5b505050508080611f3890615a72565b915050611eaa565b505050565b600080611f536108fb6110cc565b90507f0000000000000000000000000000000000000000000000000000000000000000611f896001600160481b03831682612114565b9250505090565b6040805160608101825260008082526020820181905291810191909152611fb5612825565b60009283526020908152604092839020835160608101855281546001600160481b0381168252600160481b90046001600160401b031692810192909252600101546001600160a01b0316928101929092525090565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160401b031660000361206b576020820151611143906001600160401b039060ff165b60ff1660089190911b68ffffffffffffffff00161790565b604082015182516001600160401b039182164203916000917f0000000000000000000000000000000000000000000000000000000000000000821691849160081c166001600160401b031602816120c4576120c4615b64565b602086015186516001600160401b03600892831c8116949093049390930193506000926120f79285929190911c16613ab8565b905061198f8161205387602001516001600160481b031660ff1690565b60006001600160401b03600884901c1660ff841682612134838387613ace565b9695505050505050565b33612147611920565b6001600160a01b03161415801561216757506001600160a01b0381163314155b156109f05760405163e2a08e5d60e01b8152336004820152602401610fd4565b60008061114360017fbfa91572ce1e5fe8776a160d3b1f862e83f5ee2c080a7423b4761602a3ad124a6159b7565b336121be611149565b6001600160a01b0316146110ca5760405163118cdaa760e01b8152336004820152602401610fd4565b6121ef61278c565b6121f881613b37565b6000612202612b66565b805490915060ff161561221757612217615b7a565b805460ff191660011781556040805163011fa75760e71b815290513091638fd3ab8091600480830192600092919082900301818387803b15801561225a57600080fd5b505af115801561226e573d6000803e3d6000fd5b50505050306001600160a01b031663689f90c36040518163ffffffff1660e01b8152600401602060405180830381865afa1580156122b0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906122d49190615b90565b6122e0576122e0613b77565b6122ea6000613e9b565b805460ff1916905550565b60008061230c612306600886613eb6565b84613eb6565b9050600061231b868684613ace565b90506001600160401b03811115612348576040516304041d9560e11b815260048101879052602401610fd4565b68ffffffffffffffff00600882901b1660ff831617612134565b610a2f8261236e6136bb565b61ffff8416600090815260209190915260409020613ecb565b6109f081612393612ab3565b613ecb565b60008061114360017f852fa0677fef8612c6c15b518c9fa56761e9ed15cfd5c6e5399e5467985ac7ee6159b7565b6000806123d1612b94565b905060006123dd613fd4565b905060006123e961368e565b905060006123f56126a6565b90506001600160a01b03861661241e57604051632f44bd7760e01b815260040160405180910390fd5b6001600160a01b03861660009081526020859052604090205460ff1615612469576001600160a01b0386166000908152602085905260409020805461ff001916610100179055612566565b8054604060ff909116106124905760405163891684c360e01b815260040160405180910390fd5b6040805160608101825260018082526020808301918252845460ff9081168486019081526001600160a01b038c166000908152928a905294822093518454935195518216620100000262ff0000199615156101000261ff00199215159290921661ffff1990951694909417179490941691909117909155825490911690829061251883615bad565b91906101000a81548160ff021916908360ff16021790555050612539613a39565b8054600181018255600091825260209091200180546001600160a01b0319166001600160a01b0388161790555b81546001808201845560008481526020902090910180546001600160a01b0319166001600160a01b0389161790558154610100900460ff169082906125aa83615bad565b82546101009290920a60ff8181021990931691831602179091556001600160a01b03881660009081526020879052604090205485546001620100009092049092161b6001600160401b039182168181179350911681170361262957604051638d68f84d60e01b81526001600160a01b0388166004820152602401610fd4565b835467ffffffffffffffff19166001600160401b03821617845561264b614002565b505050506001600160a01b0392909216600090815260209290925250604090205462010000900460ff1690565b60008061114360017f47028352a8b3feae1a85fba43bc13f990568bb1637dce33d3dbfd791a0808b806159b7565b60008061114360017f8561949d1c6242cee5c5a5aeb6b9c190ee611d7742fcec65d9e5b1341ea04d8a6159b7565b60008061114360017fad78307a8b51804c575f26039dcb87c58925afb3b7c08732f3b21b942aed7a776159b7565b60008061114360017f68dfeeddfa5e4e9adceec01a3aba274bdcbab3f6ac9956417a4332f2b08abddb6159b7565b60008061114360017f5443fea4dc453d96b81ce55b62e11a4094cc4cbb8a360956a7253cfdb42506cc6159b7565b60008061114360017febcc9f646b0f459ff8f387587d536b0af3484cf442e1577400f322334e7d1ef16159b7565b6001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001630036110ca57604051633c64f99360e21b815260040160405180910390fd5b6127dd614143565b6127e561395d565b6110ca614002565b60008051602061612f83398151915280546001190161281f57604051633ee5aeb560e01b815260040160405180910390fd5b60029055565b60008061114360017f4e8909a01183a67951f5a6147d6e76ed02ea890c72afea01a9edee91edc609b96159b7565b60006128886001600160481b0383167f0000000000000000000000000000000000000000000000000000000000000000612114565b60405190915084907f504e6efe18ab9eed10dc6501a417f5b12a2f7f2b1593aed9b89f9bce3cf29a9190600090a260007f000000000000000000000000000000000000000000000000000000000000000060018111156128ea576128ea6153e1565b03612928576129236001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000168483614203565b611881565b60017f0000000000000000000000000000000000000000000000000000000000000000600181111561295c5761295c6153e1565b036129e8576040516340c10f1960e01b81526001600160a01b038481166004830152602482018390527f000000000000000000000000000000000000000000000000000000000000000016906340c10f1990604401600060405180830381600087803b1580156129cb57600080fd5b505af11580156129df573d6000803e3d6000fd5b50505050611881565b7f00000000000000000000000000000000000000000000000000000000000000006001811115612a1a57612a1a6153e1565b6040516366001a8960e01b815260ff9091166004820152602401610fd4565b600160008051602061612f83398151915255565b612a55611998565b15612a73576040516309e3d0f360e11b815260040160405180910390fd5b612a7d6002614266565b604051600181527f0e2fb031ee032dc02d8011dc50b816eb450cf856abd8261680dac74f72165bd29060200160405180910390a1565b60008061114360017f7c25289a27ec8c9be54d4a154cf80490d69bda989cdb8328232e08fea92204216159b7565b600080612aec614273565b905080612af7612702565b60009485526020526040909320546101009004929092166001600160401b031692915050565b60005b6001600160401b0382161561174457612b3a600183615bcc565b9091169080612b4881615bad565b915050612b20565b600060008051602061614f833981519152610c61565b60008061114360017f7487ca88d037ca20519908b1ee7556206bef53bce0226a348750cb9d4f688e4f6159b7565b60008061114360017f49bca747e973430e858f2f5de357b8dba36ea6d375b81bdb5d53dfaabf0b3a806159b7565b600085600003612be557604051631f2a200560e01b815260040160405180910390fd5b83612c0357604051634e46966960e11b815260040160405180910390fd5b6000612c2f7f00000000000000000000000000000000000000000000000000000000000000003061427d565b9050612c666001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001633308a61432d565b6000612c927f00000000000000000000000000000000000000000000000000000000000000003061427d565b9050612c9e82826159b7565b975060017f00000000000000000000000000000000000000000000000000000000000000006001811115612cd457612cd46153e1565b03612dad57604051630852cd8d60e31b8152600481018990527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906342966c6890602401600060405180830381600087803b158015612d3b57600080fd5b505af1158015612d4f573d6000803e3d6000fd5b505050506000612d7f7f00000000000000000000000000000000000000000000000000000000000000003061427d565b9050808314612dab576040516302156a8f60e01b81526004810184905260248101829052604401610fd4565b505b50506000612dbb8787614365565b90506000612df26001600160481b0383167f0000000000000000000000000000000000000000000000000000000000000000614450565b90506000612dfe614497565b90506000612e0b836144f4565b905086158015612e185750805b15612e4957612e25611f45565b6040516326fb55dd60e01b81526004810191909152602481018b9052604401610fd4565b868015612e535750805b15612ece57337ff33512b84e24a49905c26c6991942fc5a9652411769fc1e448f967cdb049f08a838c612e84611f45565b604080516001600160401b03909416845260208401929092529082015260600160405180910390a2612eba82858b8b338b614542565b612ec33461468c565b50925061198f915050565b50612ed8826146f8565b612ee28289614748565b612ef081848a8a338a612efd565b9998505050505050505050565b600080612f0861368e565b805480602002602001604051908101604052809291908181526020018280548015612f5c57602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311612f3e575b50505050509050600073__$93083e246e55d56d98f3df2872cd16bfd0$__63b620e8728584516040518363ffffffff1660e01b8152600401612f9f929190615bec565b600060405180830381865af4158015612fbc573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612fe49190810190615c53565b9050600080612ff48984866112b3565b9150915080341015613022576040516306a91e3760e51b815260048101829052346024820152604401610fd4565b600061302e82346159b7565b9050801561303f5761303f8161468c565b5060008b9050600060405180608001604052808d6001600160481b031681526020016130917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690565b81526020018b81526020018c61ffff168152509050600073__$93083e246e55d56d98f3df2872cd16bfd0$__638b4979b86040518060600160405280866001600160401b031660001b81526020016130ef8e6001600160a01b031690565b8152604080516315cfa3cb60e11b815287516001600160481b031660048201526020888101516024830152918801516044820152606088015161ffff16606482015291019073__$93083e246e55d56d98f3df2872cd16bfd0$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'; + +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 deploy( + _token: string, + _mode: BigNumberish, + _chainId: BigNumberish, + _rateLimitDuration: BigNumberish, + _skipRateLimiting: boolean, + overrides?: Overrides & { from?: string }, + ): Promise { + return super.deploy( + _token, + _mode, + _chainId, + _rateLimitDuration, + _skipRateLimiting, + overrides || {}, + ) as Promise; + } + override getDeployTransaction( + _token: string, + _mode: BigNumberish, + _chainId: BigNumberish, + _rateLimitDuration: BigNumberish, + _skipRateLimiting: boolean, + overrides?: Overrides & { from?: string }, + ): TransactionRequest { + return super.getDeployTransaction( + _token, + _mode, + _chainId, + _rateLimitDuration, + _skipRateLimiting, + overrides || {}, + ); + } + override attach(address: string): NttManager { + return super.attach(address) as NttManager; + } + override connect(signer: Signer): NttManager__factory { + return super.connect(signer) as NttManager__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): NttManagerInterface { + return new utils.Interface(_abi) as NttManagerInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider, + ): NttManager { + return new Contract(address, _abi, signerOrProvider) as NttManager; + } +} + +export interface NttManagerLibraryAddresses { + ['src/libraries/TransceiverStructs.sol:TransceiverStructs']: string; +} diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver.ts new file mode 100644 index 000000000..eb1387cbe --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver.ts @@ -0,0 +1,1446 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { + FunctionFragment, + Result, + EventFragment, +} from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from './common'; + +export declare namespace TransceiverStructs { + export type TransceiverMessageStruct = { + sourceNttManagerAddress: BytesLike; + recipientNttManagerAddress: BytesLike; + nttManagerPayload: BytesLike; + transceiverPayload: BytesLike; + }; + + export type TransceiverMessageStructOutput = [ + string, + string, + string, + string, + ] & { + sourceNttManagerAddress: string; + recipientNttManagerAddress: string; + nttManagerPayload: string; + transceiverPayload: string; + }; + + export type TransceiverInstructionStruct = { + index: BigNumberish; + payload: BytesLike; + }; + + export type TransceiverInstructionStructOutput = [number, string] & { + index: number; + payload: string; + }; +} + +export declare namespace IWormholeTransceiver { + export type WormholeTransceiverInstructionStruct = { + shouldSkipRelayerSend: boolean; + }; + + export type WormholeTransceiverInstructionStructOutput = [boolean] & { + shouldSkipRelayerSend: boolean; + }; +} + +export interface WormholeTransceiverInterface extends utils.Interface { + functions: { + 'consistencyLevel()': FunctionFragment; + 'encodeWormholeTransceiverInstruction((bool))': FunctionFragment; + 'gasLimit()': FunctionFragment; + 'getMigratesImmutables()': FunctionFragment; + 'getNttManagerOwner()': FunctionFragment; + 'getNttManagerToken()': FunctionFragment; + 'getWormholePeer(uint16)': FunctionFragment; + 'initialize()': FunctionFragment; + 'isPaused()': FunctionFragment; + 'isSpecialRelayingEnabled(uint16)': FunctionFragment; + 'isVAAConsumed(bytes32)': FunctionFragment; + 'isWormholeEvmChain(uint16)': FunctionFragment; + 'isWormholeRelayingEnabled(uint16)': FunctionFragment; + 'migrate()': FunctionFragment; + 'nttManager()': FunctionFragment; + 'nttManagerToken()': FunctionFragment; + 'owner()': FunctionFragment; + 'parseWormholeTransceiverInstruction(bytes)': FunctionFragment; + 'pauser()': FunctionFragment; + 'quoteDeliveryPrice(uint16,(uint8,bytes))': FunctionFragment; + 'receiveMessage(bytes)': FunctionFragment; + 'receiveWormholeMessages(bytes,bytes[],bytes32,uint16,bytes32)': FunctionFragment; + 'sendMessage(uint16,(uint8,bytes),bytes,bytes32)': FunctionFragment; + 'setIsSpecialRelayingEnabled(uint16,bool)': FunctionFragment; + 'setIsWormholeEvmChain(uint16,bool)': FunctionFragment; + 'setIsWormholeRelayingEnabled(uint16,bool)': FunctionFragment; + 'setWormholePeer(uint16,bytes32)': FunctionFragment; + 'specialRelayer()': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'transferPauserCapability(address)': FunctionFragment; + 'transferTransceiverOwnership(address)': FunctionFragment; + 'upgrade(address)': FunctionFragment; + 'wormhole()': FunctionFragment; + 'wormholeRelayer()': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'consistencyLevel' + | 'encodeWormholeTransceiverInstruction' + | 'gasLimit' + | 'getMigratesImmutables' + | 'getNttManagerOwner' + | 'getNttManagerToken' + | 'getWormholePeer' + | 'initialize' + | 'isPaused' + | 'isSpecialRelayingEnabled' + | 'isVAAConsumed' + | 'isWormholeEvmChain' + | 'isWormholeRelayingEnabled' + | 'migrate' + | 'nttManager' + | 'nttManagerToken' + | 'owner' + | 'parseWormholeTransceiverInstruction' + | 'pauser' + | 'quoteDeliveryPrice' + | 'receiveMessage' + | 'receiveWormholeMessages' + | 'sendMessage' + | 'setIsSpecialRelayingEnabled' + | 'setIsWormholeEvmChain' + | 'setIsWormholeRelayingEnabled' + | 'setWormholePeer' + | 'specialRelayer' + | 'transferOwnership' + | 'transferPauserCapability' + | 'transferTransceiverOwnership' + | 'upgrade' + | 'wormhole' + | 'wormholeRelayer', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'consistencyLevel', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'encodeWormholeTransceiverInstruction', + values: [IWormholeTransceiver.WormholeTransceiverInstructionStruct], + ): string; + encodeFunctionData(functionFragment: 'gasLimit', values?: undefined): string; + encodeFunctionData( + functionFragment: 'getMigratesImmutables', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getNttManagerOwner', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getNttManagerToken', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getWormholePeer', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'initialize', + values?: undefined, + ): string; + encodeFunctionData(functionFragment: 'isPaused', values?: undefined): string; + encodeFunctionData( + functionFragment: 'isSpecialRelayingEnabled', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'isVAAConsumed', + values: [BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'isWormholeEvmChain', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'isWormholeRelayingEnabled', + values: [BigNumberish], + ): string; + encodeFunctionData(functionFragment: 'migrate', values?: undefined): string; + encodeFunctionData( + functionFragment: 'nttManager', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'nttManagerToken', + values?: undefined, + ): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData( + functionFragment: 'parseWormholeTransceiverInstruction', + values: [BytesLike], + ): string; + encodeFunctionData(functionFragment: 'pauser', values?: undefined): string; + encodeFunctionData( + functionFragment: 'quoteDeliveryPrice', + values: [BigNumberish, TransceiverStructs.TransceiverInstructionStruct], + ): string; + encodeFunctionData( + functionFragment: 'receiveMessage', + values: [BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'receiveWormholeMessages', + values: [BytesLike, BytesLike[], BytesLike, BigNumberish, BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'sendMessage', + values: [ + BigNumberish, + TransceiverStructs.TransceiverInstructionStruct, + BytesLike, + BytesLike, + ], + ): string; + encodeFunctionData( + functionFragment: 'setIsSpecialRelayingEnabled', + values: [BigNumberish, boolean], + ): string; + encodeFunctionData( + functionFragment: 'setIsWormholeEvmChain', + values: [BigNumberish, boolean], + ): string; + encodeFunctionData( + functionFragment: 'setIsWormholeRelayingEnabled', + values: [BigNumberish, boolean], + ): string; + encodeFunctionData( + functionFragment: 'setWormholePeer', + values: [BigNumberish, BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'specialRelayer', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'transferOwnership', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'transferPauserCapability', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'transferTransceiverOwnership', + values: [string], + ): string; + encodeFunctionData(functionFragment: 'upgrade', values: [string]): string; + encodeFunctionData(functionFragment: 'wormhole', values?: undefined): string; + encodeFunctionData( + functionFragment: 'wormholeRelayer', + values?: undefined, + ): string; + + decodeFunctionResult( + functionFragment: 'consistencyLevel', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'encodeWormholeTransceiverInstruction', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'gasLimit', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'getMigratesImmutables', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getNttManagerOwner', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getNttManagerToken', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getWormholePeer', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'isPaused', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'isSpecialRelayingEnabled', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'isVAAConsumed', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'isWormholeEvmChain', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'isWormholeRelayingEnabled', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'migrate', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'nttManager', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'nttManagerToken', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'parseWormholeTransceiverInstruction', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'pauser', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'quoteDeliveryPrice', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'receiveMessage', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'receiveWormholeMessages', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'sendMessage', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setIsSpecialRelayingEnabled', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setIsWormholeEvmChain', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setIsWormholeRelayingEnabled', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setWormholePeer', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'specialRelayer', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferOwnership', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferPauserCapability', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferTransceiverOwnership', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'upgrade', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'wormhole', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'wormholeRelayer', + data: BytesLike, + ): Result; + + events: { + 'AdminChanged(address,address)': EventFragment; + 'BeaconUpgraded(address)': EventFragment; + 'Initialized(uint64)': EventFragment; + 'NotPaused(bool)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'Paused(bool)': EventFragment; + 'PauserTransferred(address,address)': EventFragment; + 'ReceivedMessage(bytes32,uint16,bytes32,uint64)': EventFragment; + 'ReceivedRelayedMessage(bytes32,uint16,bytes32)': EventFragment; + 'RelayingInfo(uint8,uint256)': EventFragment; + 'SendTransceiverMessage(uint16,(bytes32,bytes32,bytes,bytes))': EventFragment; + 'SetIsSpecialRelayingEnabled(uint16,bool)': EventFragment; + 'SetIsWormholeEvmChain(uint16,bool)': EventFragment; + 'SetIsWormholeRelayingEnabled(uint16,bool)': EventFragment; + 'SetWormholePeer(uint16,bytes32)': EventFragment; + 'Upgraded(address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'AdminChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'BeaconUpgraded'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'NotPaused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'PauserTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ReceivedMessage'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ReceivedRelayedMessage'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RelayingInfo'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'SendTransceiverMessage'): EventFragment; + getEvent( + nameOrSignatureOrTopic: 'SetIsSpecialRelayingEnabled', + ): EventFragment; + getEvent(nameOrSignatureOrTopic: 'SetIsWormholeEvmChain'): EventFragment; + getEvent( + nameOrSignatureOrTopic: 'SetIsWormholeRelayingEnabled', + ): EventFragment; + getEvent(nameOrSignatureOrTopic: 'SetWormholePeer'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Upgraded'): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface InitializedEventObject { + version: BigNumber; +} +export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface NotPausedEventObject { + notPaused: boolean; +} +export type NotPausedEvent = TypedEvent<[boolean], NotPausedEventObject>; + +export type NotPausedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface PausedEventObject { + paused: boolean; +} +export type PausedEvent = TypedEvent<[boolean], PausedEventObject>; + +export type PausedEventFilter = TypedEventFilter; + +export interface PauserTransferredEventObject { + oldPauser: string; + newPauser: string; +} +export type PauserTransferredEvent = TypedEvent< + [string, string], + PauserTransferredEventObject +>; + +export type PauserTransferredEventFilter = + TypedEventFilter; + +export interface ReceivedMessageEventObject { + digest: string; + emitterChainId: number; + emitterAddress: string; + sequence: BigNumber; +} +export type ReceivedMessageEvent = TypedEvent< + [string, number, string, BigNumber], + ReceivedMessageEventObject +>; + +export type ReceivedMessageEventFilter = TypedEventFilter; + +export interface ReceivedRelayedMessageEventObject { + digest: string; + emitterChainId: number; + emitterAddress: string; +} +export type ReceivedRelayedMessageEvent = TypedEvent< + [string, number, string], + ReceivedRelayedMessageEventObject +>; + +export type ReceivedRelayedMessageEventFilter = + TypedEventFilter; + +export interface RelayingInfoEventObject { + relayingType: number; + deliveryPayment: BigNumber; +} +export type RelayingInfoEvent = TypedEvent< + [number, BigNumber], + RelayingInfoEventObject +>; + +export type RelayingInfoEventFilter = TypedEventFilter; + +export interface SendTransceiverMessageEventObject { + recipientChain: number; + message: TransceiverStructs.TransceiverMessageStructOutput; +} +export type SendTransceiverMessageEvent = TypedEvent< + [number, TransceiverStructs.TransceiverMessageStructOutput], + SendTransceiverMessageEventObject +>; + +export type SendTransceiverMessageEventFilter = + TypedEventFilter; + +export interface SetIsSpecialRelayingEnabledEventObject { + chainId: number; + isRelayingEnabled: boolean; +} +export type SetIsSpecialRelayingEnabledEvent = TypedEvent< + [number, boolean], + SetIsSpecialRelayingEnabledEventObject +>; + +export type SetIsSpecialRelayingEnabledEventFilter = + TypedEventFilter; + +export interface SetIsWormholeEvmChainEventObject { + chainId: number; + isEvm: boolean; +} +export type SetIsWormholeEvmChainEvent = TypedEvent< + [number, boolean], + SetIsWormholeEvmChainEventObject +>; + +export type SetIsWormholeEvmChainEventFilter = + TypedEventFilter; + +export interface SetIsWormholeRelayingEnabledEventObject { + chainId: number; + isRelayingEnabled: boolean; +} +export type SetIsWormholeRelayingEnabledEvent = TypedEvent< + [number, boolean], + SetIsWormholeRelayingEnabledEventObject +>; + +export type SetIsWormholeRelayingEnabledEventFilter = + TypedEventFilter; + +export interface SetWormholePeerEventObject { + chainId: number; + peerContract: string; +} +export type SetWormholePeerEvent = TypedEvent< + [number, string], + SetWormholePeerEventObject +>; + +export type SetWormholePeerEventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface WormholeTransceiver extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: WormholeTransceiverInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined, + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter, + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter, + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + consistencyLevel(overrides?: CallOverrides): Promise<[number]>; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise<[string]>; + + gasLimit(overrides?: CallOverrides): Promise<[BigNumber]>; + + getMigratesImmutables(overrides?: CallOverrides): Promise<[boolean]>; + + getNttManagerOwner(overrides?: CallOverrides): Promise<[string]>; + + getNttManagerToken(overrides?: CallOverrides): Promise<[string]>; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise<[string]>; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise<[boolean]>; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isVAAConsumed( + hash: BytesLike, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + nttManager(overrides?: CallOverrides): Promise<[string]>; + + nttManagerToken(overrides?: CallOverrides): Promise<[string]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise< + [IWormholeTransceiver.WormholeTransceiverInstructionStructOutput] & { + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStructOutput; + } + >; + + pauser(overrides?: CallOverrides): Promise<[string]>; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise<[string]>; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise<[string]>; + + wormholeRelayer(overrides?: CallOverrides): Promise<[string]>; + }; + + consistencyLevel(overrides?: CallOverrides): Promise; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + gasLimit(overrides?: CallOverrides): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getNttManagerOwner(overrides?: CallOverrides): Promise; + + getNttManagerToken(overrides?: CallOverrides): Promise; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isVAAConsumed(hash: BytesLike, overrides?: CallOverrides): Promise; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + nttManager(overrides?: CallOverrides): Promise; + + nttManagerToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise; + + wormholeRelayer(overrides?: CallOverrides): Promise; + + callStatic: { + consistencyLevel(overrides?: CallOverrides): Promise; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + gasLimit(overrides?: CallOverrides): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getNttManagerOwner(overrides?: CallOverrides): Promise; + + getNttManagerToken(overrides?: CallOverrides): Promise; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize(overrides?: CallOverrides): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isVAAConsumed(hash: BytesLike, overrides?: CallOverrides): Promise; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + migrate(overrides?: CallOverrides): Promise; + + nttManager(overrides?: CallOverrides): Promise; + + nttManagerToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: CallOverrides, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: CallOverrides, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: CallOverrides, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: CallOverrides, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: CallOverrides, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: CallOverrides, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: CallOverrides, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: CallOverrides, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: CallOverrides, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: CallOverrides, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: CallOverrides, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise; + + wormholeRelayer(overrides?: CallOverrides): Promise; + }; + + filters: { + 'AdminChanged(address,address)'( + previousAdmin?: null, + newAdmin?: null, + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null, + ): AdminChangedEventFilter; + + 'BeaconUpgraded(address)'( + beacon?: string | null, + ): BeaconUpgradedEventFilter; + BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter; + + 'Initialized(uint64)'(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + 'NotPaused(bool)'(notPaused?: null): NotPausedEventFilter; + NotPaused(notPaused?: null): NotPausedEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + + 'Paused(bool)'(paused?: null): PausedEventFilter; + Paused(paused?: null): PausedEventFilter; + + 'PauserTransferred(address,address)'( + oldPauser?: string | null, + newPauser?: string | null, + ): PauserTransferredEventFilter; + PauserTransferred( + oldPauser?: string | null, + newPauser?: string | null, + ): PauserTransferredEventFilter; + + 'ReceivedMessage(bytes32,uint16,bytes32,uint64)'( + digest?: null, + emitterChainId?: null, + emitterAddress?: null, + sequence?: null, + ): ReceivedMessageEventFilter; + ReceivedMessage( + digest?: null, + emitterChainId?: null, + emitterAddress?: null, + sequence?: null, + ): ReceivedMessageEventFilter; + + 'ReceivedRelayedMessage(bytes32,uint16,bytes32)'( + digest?: null, + emitterChainId?: null, + emitterAddress?: null, + ): ReceivedRelayedMessageEventFilter; + ReceivedRelayedMessage( + digest?: null, + emitterChainId?: null, + emitterAddress?: null, + ): ReceivedRelayedMessageEventFilter; + + 'RelayingInfo(uint8,uint256)'( + relayingType?: null, + deliveryPayment?: null, + ): RelayingInfoEventFilter; + RelayingInfo( + relayingType?: null, + deliveryPayment?: null, + ): RelayingInfoEventFilter; + + 'SendTransceiverMessage(uint16,(bytes32,bytes32,bytes,bytes))'( + recipientChain?: null, + message?: null, + ): SendTransceiverMessageEventFilter; + SendTransceiverMessage( + recipientChain?: null, + message?: null, + ): SendTransceiverMessageEventFilter; + + 'SetIsSpecialRelayingEnabled(uint16,bool)'( + chainId?: null, + isRelayingEnabled?: null, + ): SetIsSpecialRelayingEnabledEventFilter; + SetIsSpecialRelayingEnabled( + chainId?: null, + isRelayingEnabled?: null, + ): SetIsSpecialRelayingEnabledEventFilter; + + 'SetIsWormholeEvmChain(uint16,bool)'( + chainId?: null, + isEvm?: null, + ): SetIsWormholeEvmChainEventFilter; + SetIsWormholeEvmChain( + chainId?: null, + isEvm?: null, + ): SetIsWormholeEvmChainEventFilter; + + 'SetIsWormholeRelayingEnabled(uint16,bool)'( + chainId?: null, + isRelayingEnabled?: null, + ): SetIsWormholeRelayingEnabledEventFilter; + SetIsWormholeRelayingEnabled( + chainId?: null, + isRelayingEnabled?: null, + ): SetIsWormholeRelayingEnabledEventFilter; + + 'SetWormholePeer(uint16,bytes32)'( + chainId?: null, + peerContract?: null, + ): SetWormholePeerEventFilter; + SetWormholePeer( + chainId?: null, + peerContract?: null, + ): SetWormholePeerEventFilter; + + 'Upgraded(address)'(implementation?: string | null): UpgradedEventFilter; + Upgraded(implementation?: string | null): UpgradedEventFilter; + }; + + estimateGas: { + consistencyLevel(overrides?: CallOverrides): Promise; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + gasLimit(overrides?: CallOverrides): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getNttManagerOwner(overrides?: CallOverrides): Promise; + + getNttManagerToken(overrides?: CallOverrides): Promise; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize(overrides?: Overrides & { from?: string }): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isVAAConsumed( + hash: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + migrate(overrides?: Overrides & { from?: string }): Promise; + + nttManager(overrides?: CallOverrides): Promise; + + nttManagerToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise; + + wormholeRelayer(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + consistencyLevel(overrides?: CallOverrides): Promise; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + gasLimit(overrides?: CallOverrides): Promise; + + getMigratesImmutables( + overrides?: CallOverrides, + ): Promise; + + getNttManagerOwner( + overrides?: CallOverrides, + ): Promise; + + getNttManagerToken( + overrides?: CallOverrides, + ): Promise; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isVAAConsumed( + hash: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + nttManager(overrides?: CallOverrides): Promise; + + nttManagerToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise; + + wormholeRelayer(overrides?: CallOverrides): Promise; + }; +} diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver__factory.ts b/wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver__factory.ts new file mode 100644 index 000000000..a6783b4a5 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver__factory.ts @@ -0,0 +1,1351 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { + Signer, + utils, + Contract, + ContractFactory, + BigNumberish, + Overrides, +} from 'ethers'; +import type { Provider, TransactionRequest } from '@ethersproject/providers'; +import type { + WormholeTransceiver, + WormholeTransceiverInterface, +} from './WormholeTransceiver'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: 'nttManager', + type: 'address', + }, + { + internalType: 'address', + name: 'wormholeCoreBridge', + type: 'address', + }, + { + internalType: 'address', + name: 'wormholeRelayerAddr', + type: 'address', + }, + { + internalType: 'address', + name: 'specialRelayerAddr', + type: 'address', + }, + { + internalType: 'uint8', + name: '_consistencyLevel', + type: 'uint8', + }, + { + internalType: 'uint256', + name: '_gasLimit', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [ + { + internalType: 'address', + name: 'caller', + type: 'address', + }, + ], + name: 'CallerNotNttManager', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'caller', + type: 'address', + }, + ], + name: 'CallerNotRelayer', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'currentOwner', + type: 'address', + }, + ], + name: 'CannotRenounceTransceiverOwnership', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'currentOwner', + type: 'address', + }, + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'CannotTransferTransceiverOwnership', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint8', + name: 'val', + type: 'uint8', + }, + ], + name: 'InvalidBoolVal', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'value', + type: 'uint256', + }, + ], + name: 'InvalidBoolValue', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'evmChainId', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'blockChainId', + type: 'uint256', + }, + ], + name: 'InvalidFork', + type: 'error', + }, + { + inputs: [], + name: 'InvalidInitialization', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'InvalidPauser', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'InvalidRelayingConfig', + type: 'error', + }, + { + inputs: [ + { + internalType: 'string', + name: 'reason', + type: 'string', + }, + ], + name: 'InvalidVaa', + type: 'error', + }, + { + inputs: [], + name: 'InvalidWormholeChainIdZero', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerAddress', + type: 'bytes32', + }, + ], + name: 'InvalidWormholePeer', + type: 'error', + }, + { + inputs: [], + name: 'InvalidWormholePeerZeroAddress', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'encodedLength', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'expectedLength', + type: 'uint256', + }, + ], + name: 'LengthMismatch', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: '', + type: 'bytes32', + }, + ], + name: 'NotAnEvmAddress', + type: 'error', + }, + { + inputs: [], + name: 'NotInitializing', + type: 'error', + }, + { + inputs: [], + name: 'NotMigrating', + type: 'error', + }, + { + inputs: [], + name: 'OnlyDelegateCall', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'OwnableInvalidOwner', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'OwnableUnauthorizedAccount', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerAddress', + type: 'bytes32', + }, + ], + name: 'PeerAlreadySet', + type: 'error', + }, + { + inputs: [], + name: 'ReentrancyGuardReentrantCall', + type: 'error', + }, + { + inputs: [], + name: 'RequireContractIsNotPaused', + type: 'error', + }, + { + inputs: [], + name: 'RequireContractIsPaused', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'vaaHash', + type: 'bytes32', + }, + ], + name: 'TransferAlreadyCompleted', + type: 'error', + }, + { + inputs: [], + name: 'UnexpectedAdditionalMessages', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'deployer', + type: 'address', + }, + { + internalType: 'address', + name: 'caller', + type: 'address', + }, + ], + name: 'UnexpectedDeployer', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'recipientNttManagerAddress', + type: 'bytes32', + }, + { + internalType: 'bytes32', + name: 'expectedRecipientNttManagerAddress', + type: 'bytes32', + }, + ], + name: 'UnexpectedRecipientNttManagerAddress', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'previousAdmin', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'newAdmin', + type: 'address', + }, + ], + name: 'AdminChanged', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'beacon', + type: 'address', + }, + ], + name: 'BeaconUpgraded', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint64', + name: 'version', + type: 'uint64', + }, + ], + name: 'Initialized', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bool', + name: 'notPaused', + type: 'bool', + }, + ], + name: 'NotPaused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'previousOwner', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnershipTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bool', + name: 'paused', + type: 'bool', + }, + ], + name: 'Paused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'oldPauser', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newPauser', + type: 'address', + }, + ], + name: 'PauserTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint16', + name: 'emitterChainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'emitterAddress', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint64', + name: 'sequence', + type: 'uint64', + }, + ], + name: 'ReceivedMessage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint16', + name: 'emitterChainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'emitterAddress', + type: 'bytes32', + }, + ], + name: 'ReceivedRelayedMessage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint8', + name: 'relayingType', + type: 'uint8', + }, + { + indexed: false, + internalType: 'uint256', + name: 'deliveryPayment', + type: 'uint256', + }, + ], + name: 'RelayingInfo', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + components: [ + { + internalType: 'bytes32', + name: 'sourceNttManagerAddress', + type: 'bytes32', + }, + { + internalType: 'bytes32', + name: 'recipientNttManagerAddress', + type: 'bytes32', + }, + { + internalType: 'bytes', + name: 'nttManagerPayload', + type: 'bytes', + }, + { + internalType: 'bytes', + name: 'transceiverPayload', + type: 'bytes', + }, + ], + indexed: false, + internalType: 'struct TransceiverStructs.TransceiverMessage', + name: 'message', + type: 'tuple', + }, + ], + name: 'SendTransceiverMessage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bool', + name: 'isRelayingEnabled', + type: 'bool', + }, + ], + name: 'SetIsSpecialRelayingEnabled', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bool', + name: 'isEvm', + type: 'bool', + }, + ], + name: 'SetIsWormholeEvmChain', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bool', + name: 'isRelayingEnabled', + type: 'bool', + }, + ], + name: 'SetIsWormholeRelayingEnabled', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'peerContract', + type: 'bytes32', + }, + ], + name: 'SetWormholePeer', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'implementation', + type: 'address', + }, + ], + name: 'Upgraded', + type: 'event', + }, + { + inputs: [], + name: 'consistencyLevel', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + components: [ + { + internalType: 'bool', + name: 'shouldSkipRelayerSend', + type: 'bool', + }, + ], + internalType: + 'struct IWormholeTransceiver.WormholeTransceiverInstruction', + name: 'instruction', + type: 'tuple', + }, + ], + name: 'encodeWormholeTransceiverInstruction', + outputs: [ + { + internalType: 'bytes', + name: '', + type: 'bytes', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [], + name: 'gasLimit', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getMigratesImmutables', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getNttManagerOwner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getNttManagerToken', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'getWormholePeer', + outputs: [ + { + internalType: 'bytes32', + name: '', + type: 'bytes32', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'initialize', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'isPaused', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'isSpecialRelayingEnabled', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'hash', + type: 'bytes32', + }, + ], + name: 'isVAAConsumed', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'isWormholeEvmChain', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'isWormholeRelayingEnabled', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'migrate', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'nttManager', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'nttManagerToken', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes', + name: 'encoded', + type: 'bytes', + }, + ], + name: 'parseWormholeTransceiverInstruction', + outputs: [ + { + components: [ + { + internalType: 'bool', + name: 'shouldSkipRelayerSend', + type: 'bool', + }, + ], + internalType: + 'struct IWormholeTransceiver.WormholeTransceiverInstruction', + name: 'instruction', + type: 'tuple', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [], + name: 'pauser', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'targetChain', + type: 'uint16', + }, + { + components: [ + { + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.TransceiverInstruction', + name: 'instruction', + type: 'tuple', + }, + ], + name: 'quoteDeliveryPrice', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes', + name: 'encodedMessage', + type: 'bytes', + }, + ], + name: 'receiveMessage', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + { + internalType: 'bytes[]', + name: 'additionalMessages', + type: 'bytes[]', + }, + { + internalType: 'bytes32', + name: 'sourceAddress', + type: 'bytes32', + }, + { + internalType: 'uint16', + name: 'sourceChain', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'deliveryHash', + type: 'bytes32', + }, + ], + name: 'receiveWormholeMessages', + outputs: [], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + components: [ + { + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.TransceiverInstruction', + name: 'instruction', + type: 'tuple', + }, + { + internalType: 'bytes', + name: 'nttManagerMessage', + type: 'bytes', + }, + { + internalType: 'bytes32', + name: 'recipientNttManagerAddress', + type: 'bytes32', + }, + ], + name: 'sendMessage', + outputs: [], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bool', + name: 'isEnabled', + type: 'bool', + }, + ], + name: 'setIsSpecialRelayingEnabled', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bool', + name: 'isEvm', + type: 'bool', + }, + ], + name: 'setIsWormholeEvmChain', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bool', + name: 'isEnabled', + type: 'bool', + }, + ], + name: 'setIsWormholeRelayingEnabled', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'peerChainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerContract', + type: 'bytes32', + }, + ], + name: 'setWormholePeer', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'specialRelayer', + outputs: [ + { + internalType: 'contract ISpecialRelayer', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newPauser', + type: 'address', + }, + ], + name: 'transferPauserCapability', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferTransceiverOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newImplementation', + type: 'address', + }, + ], + name: 'upgrade', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'wormhole', + outputs: [ + { + internalType: 'contract IWormhole', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'wormholeRelayer', + outputs: [ + { + internalType: 'contract IWormholeRelayer', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, +] as const; + +const _bytecode = + '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__$93083e246e55d56d98f3df2872cd16bfd0$__906308a700d690610a24906309945ff160e41b908b9060040161322b565b600060405180830381865af4158015610a41573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610a699190810190613314565b81516020830151929450909250610a8391869190846116a4565b50505050505050565b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614610ad75760405163c5aa615360e01b81523360048201526024016108d0565b61077f816117a7565b610ae86113fc565b8161ffff16600003610b0d57604051630f7662c960e21b815260040160405180910390fd5b610b1681611631565b610b1e61153e565b61ffff841660008181526020928352604090819020939093558251908152831515918101919091527f528b18a533e892b5401d1fb63597275df9d2bb45b13e7695c3147cd07b9746c3910161087d565b6000610b78611818565b5460ff16919050565b610b896113fc565b8161ffff16600003610bae57604051630f7662c960e21b815260040160405180910390fd5b80610bcc5760405163137063ef60e11b815260040160405180910390fd5b6000610bd6611846565b61ffff84166000908152602091909152604090205490508015610c195760405163b55eeae960e01b815261ffff84166004820152602481018290526044016108d0565b81610c22611846565b61ffff858116600081815260209384526040808220959095558451606081018652630c7e33e160e11b8152938401918252838501878152945163077650fb60e51b815284516001600160e01b0319166004820152915190921660248201529251604484015290917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169163b19a437e9173__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$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'; + +type WormholeTransceiverConstructorParams = + | [linkLibraryAddresses: WormholeTransceiverLibraryAddresses, signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: WormholeTransceiverConstructorParams, +): 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 WormholeTransceiver__factory extends ContractFactory { + constructor(...args: WormholeTransceiverConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + const [linkLibraryAddresses, signer] = args; + super( + _abi, + WormholeTransceiver__factory.linkBytecode(linkLibraryAddresses), + signer, + ); + } + } + + static linkBytecode( + linkLibraryAddresses: WormholeTransceiverLibraryAddresses, + ): string { + let linkedBytecode = _bytecode; + + linkedBytecode = linkedBytecode.replace( + new RegExp('__\\$93083e246e55d56d98f3df2872cd16bfd0\\$__', 'g'), + linkLibraryAddresses[ + 'src/libraries/TransceiverStructs.sol:TransceiverStructs' + ] + .replace(/^0x/, '') + .toLowerCase(), + ); + + return linkedBytecode; + } + + override deploy( + nttManager: string, + wormholeCoreBridge: string, + wormholeRelayerAddr: string, + specialRelayerAddr: string, + _consistencyLevel: BigNumberish, + _gasLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise { + return super.deploy( + nttManager, + wormholeCoreBridge, + wormholeRelayerAddr, + specialRelayerAddr, + _consistencyLevel, + _gasLimit, + overrides || {}, + ) as Promise; + } + override getDeployTransaction( + nttManager: string, + wormholeCoreBridge: string, + wormholeRelayerAddr: string, + specialRelayerAddr: string, + _consistencyLevel: BigNumberish, + _gasLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): TransactionRequest { + return super.getDeployTransaction( + nttManager, + wormholeCoreBridge, + wormholeRelayerAddr, + specialRelayerAddr, + _consistencyLevel, + _gasLimit, + overrides || {}, + ); + } + override attach(address: string): WormholeTransceiver { + return super.attach(address) as WormholeTransceiver; + } + override connect(signer: Signer): WormholeTransceiver__factory { + return super.connect(signer) as WormholeTransceiver__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): WormholeTransceiverInterface { + return new utils.Interface(_abi) as WormholeTransceiverInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider, + ): WormholeTransceiver { + return new Contract(address, _abi, signerOrProvider) as WormholeTransceiver; + } +} + +export interface WormholeTransceiverLibraryAddresses { + ['src/libraries/TransceiverStructs.sol:TransceiverStructs']: string; +} diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/common.ts b/wormhole-connect/src/routes/ntt/platforms/evm/abis/common.ts new file mode 100644 index 000000000..c24bb0674 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/abis/common.ts @@ -0,0 +1,46 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { Listener } from '@ethersproject/providers'; +import type { Event, EventFilter } from 'ethers'; + +export interface TypedEvent< + TArgsArray extends Array = any, + TArgsObject = any, +> extends Event { + args: TArgsArray & TArgsObject; +} + +export interface TypedEventFilter<_TEvent extends TypedEvent> + extends EventFilter {} + +export interface TypedListener { + (...listenerArg: [...__TypechainArgsArray, TEvent]): void; +} + +type __TypechainArgsArray = T extends TypedEvent ? U : never; + +export interface OnEvent { + ( + eventFilter: TypedEventFilter, + listener: TypedListener, + ): TRes; + (eventName: string, listener: Listener): TRes; +} + +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 PromiseOrValue = T | Promise; diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/index.ts b/wormhole-connect/src/routes/ntt/platforms/evm/abis/index.ts new file mode 100644 index 000000000..a0955ab2e --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/abis/index.ts @@ -0,0 +1,3 @@ +export * from './NttManager__factory'; +export * from './NttManager'; +export * from './WormholeTransceiver__factory'; diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts b/wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts new file mode 100644 index 000000000..e921c1150 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts @@ -0,0 +1,117 @@ +import { ChainName, ChainId } from '@wormhole-foundation/wormhole-connect-sdk'; +import { Implementation__factory } from '@certusone/wormhole-sdk/lib/esm/ethers-contracts'; +import { + parseWormholeLog, + RelayerPayloadId, + DeliveryInstruction, +} from '@certusone/wormhole-sdk/lib/esm/relayer'; +import { ethers } from 'ethers'; +import { hexlify } from 'ethers/lib/utils'; +import { NttRelayingType, UnsignedNttMessage } from 'routes/types'; +import { getNttToken } from 'store/transferInput'; +import { getTokenById, getTokenDecimals } from 'utils'; +import { getWormholeLogEvm } from 'utils/vaa'; +import { NttManager__factory } from './abis'; +import { + getNttManagerMessageDigest, + parseWormholeTransceiverMessage, +} from 'routes/ntt/utils'; +import config from 'config'; +import { toChainId, toChainName } from 'utils/sdk'; + +const RELAYING_INFO_EVENT_TOPIC = + '0x375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271'; +const RELAYING_INFO_IFACE = new ethers.utils.Interface([ + 'event RelayingInfo(uint8 relayingType, uint256 deliveryPayment)', +]); + +export const getMessageEvm = async ( + tx: string, + chain: ChainName | ChainId, + receipt?: ethers.providers.TransactionReceipt, +): Promise => { + const provider = config.wh.mustGetProvider(chain); + if (!receipt) { + receipt = await provider.getTransactionReceipt(tx); + if (!receipt) { + throw new Error(`No receipt for tx ${tx} on ${chain}`); + } + } + const nttManager = NttManager__factory.connect(receipt.to, provider); + const tokenAddress = await nttManager.token(); + const fromChain = toChainName(chain); + const tokenId = { + chain: fromChain, + address: tokenAddress, + }; + const token = getTokenById(tokenId); + if (!token?.ntt) { + throw new Error(`Token ${tokenId} not found`); + } + const wormholeLog = await getWormholeLogEvm(fromChain, receipt); + const parsedWormholeLog = + Implementation__factory.createInterface().parseLog(wormholeLog); + const relayingInfoEvent = receipt.logs.find( + (log) => log.topics[0] === RELAYING_INFO_EVENT_TOPIC, + ); + if (!relayingInfoEvent) { + throw new Error('RelayingInfo event not found'); + } + const parsedRelayingInfo = RELAYING_INFO_IFACE.parseLog(relayingInfoEvent); + const { relayingType, deliveryPayment } = parsedRelayingInfo.args; + let payload: Buffer; + if (relayingType === NttRelayingType.Standard) { + const { type, parsed } = parseWormholeLog(wormholeLog); + if (type !== RelayerPayloadId.Delivery) { + throw new Error(`Unexpected standard relayer payload type ${type}`); + } + payload = (parsed as DeliveryInstruction).payload; + } else if ( + relayingType === NttRelayingType.Manual || + relayingType === NttRelayingType.Special + ) { + payload = Buffer.from(parsedWormholeLog.args.payload.slice(2), 'hex'); + } else { + throw new Error(`Unexpected relaying type ${relayingType}`); + } + const transceiverMessage = parseWormholeTransceiverMessage(payload); + const nttManagerMessage = transceiverMessage.nttManagerPayload; + const toChain = toChainName( + nttManagerMessage.payload.recipientChain as ChainId, + ); + const receivedTokenKey = getNttToken(token.ntt.groupId, toChain); + if (!receivedTokenKey) { + throw new Error(`Received token key not found for ${tokenId}`); + } + return { + sendTx: receipt.transactionHash, + sender: receipt.from, + amount: nttManagerMessage.payload.trimmedAmount.amount.toString(), + payloadID: 0, + recipient: config.wh.parseAddress( + nttManagerMessage.payload.recipientAddress, + toChain, + ), + toChain, + fromChain, + tokenAddress, + tokenChain: token.nativeChain, + tokenId, + tokenKey: token.key, + tokenDecimals: getTokenDecimals(toChainId(fromChain), tokenId), + receivedTokenKey, + emitterAddress: hexlify( + config.wh.formatAddress(parsedWormholeLog.args.sender, fromChain), + ), + sequence: parsedWormholeLog.args.sequence.toString(), + block: receipt.blockNumber, + gasFee: receipt.gasUsed.mul(receipt.effectiveGasPrice).toString(), + recipientNttManager: config.wh.parseAddress( + hexlify(transceiverMessage.recipientNttManager), + toChain, + ), + messageDigest: getNttManagerMessageDigest(fromChain, nttManagerMessage), + relayerFee: deliveryPayment.toString(), + relayingType, + }; +}; diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/index.ts b/wormhole-connect/src/routes/ntt/platforms/evm/index.ts new file mode 100644 index 000000000..7ce665aea --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/index.ts @@ -0,0 +1,3 @@ +export * from './nttManager'; +export * from './getMessage'; +export * from './wormholeTransceiver'; diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/nttManager.ts b/wormhole-connect/src/routes/ntt/platforms/evm/nttManager.ts new file mode 100644 index 000000000..273a44c82 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/nttManager.ts @@ -0,0 +1,232 @@ +import { + ChainId, + ChainName, + EthContext, + TokenId, + WormholeContext, +} from '@wormhole-foundation/wormhole-connect-sdk'; +import { getTokenById, tryParseErrorMessage } from 'utils'; +import { TransferWallet, signAndSendTransaction } from 'utils/wallet'; +import { BigNumber, PopulatedTransaction } from 'ethers'; +import { InboundQueuedTransfer } from '../../types'; +import { + InboundQueuedTransferNotFoundError, + InboundQueuedTransferStillQueuedError, + NotEnoughCapacityError, + ContractIsPausedError, +} from '../../errors'; +import { + encodeTransceiverInstructions, + encodeWormholeTransceiverInstruction, +} from 'routes/ntt/utils'; +import { NttManager__factory } from './abis/NttManager__factory'; +import { NttManager as NttManagerAbi } from './abis/NttManager'; +import config from 'config'; +import { toChainId, toChainName } from 'utils/sdk'; + +export class NttManagerEvm { + readonly nttManager: NttManagerAbi; + + constructor(readonly chain: ChainName | ChainId, address: string) { + this.nttManager = NttManager__factory.connect( + address, + config.wh.mustGetProvider(chain), + ); + } + + async signAndSendTransaction( + tx: PopulatedTransaction, + walletType: TransferWallet, + ): Promise { + const signer = await config.wh.mustGetSigner(this.chain); + const response = await signer.sendTransaction(tx); + const receipt = await response.wait(); + const txId = await signAndSendTransaction( + toChainName(this.chain), + receipt, + walletType, + ); + return txId; + } + + // Quotes the delivery price using the wormhole transceiver + async quoteDeliveryPrice( + destChain: ChainName | ChainId, + wormholeTransceiver: string, + ): Promise { + // TODO: when this change is deployed, change to encodeTransceiverInstructions + // https://github.com/wormhole-foundation/example-native-token-transfers/pull/286 + // const transceiverIxs = encodeTransceiverInstructions([ + // { + // index: 0, + // payload: encodeWormholeTransceiverInstruction({ + // shouldSkipRelayerSend, + // }), + // }, + // ]); + const transceiverIxs = [ + { + index: 0, + payload: encodeWormholeTransceiverInstruction({ + shouldSkipRelayerSend: false, + }), + }, + ]; + const [, deliveryPrice] = await this.nttManager.quoteDeliveryPrice( + toChainId(destChain), + transceiverIxs, + [wormholeTransceiver], + ); + return deliveryPrice.toString(); + } + + async send( + token: TokenId, + sender: string, + recipient: string, + amount: bigint, + toChain: ChainName | ChainId, + shouldSkipRelayerSend: boolean, + ): Promise { + const tokenConfig = getTokenById(token); + if (!tokenConfig?.ntt?.wormholeTransceiver) { + throw new Error('no wormhole transceiver'); + } + const deliveryPrice = shouldSkipRelayerSend + ? undefined + : BigNumber.from( + await this.quoteDeliveryPrice( + toChain, + tokenConfig.ntt.wormholeTransceiver, + ), + ); + const transceiverIxs = encodeTransceiverInstructions([ + { + index: 0, + payload: encodeWormholeTransceiverInstruction({ + shouldSkipRelayerSend, + }), + }, + ]); + const tx = await this.nttManager.populateTransaction[ + 'transfer(uint256,uint16,bytes32,bool,bytes)' + ]( + amount, + toChainId(toChain), + config.wh.formatAddress(recipient, toChain), + false, // revert instead of getting outbound queued + transceiverIxs, + { value: deliveryPrice }, + ); + const context = config.wh.getContext( + this.chain, + ) as EthContext; + await context.approve( + this.chain, + this.nttManager.address, + token.address, + amount, + ); + try { + return await this.signAndSendTransaction(tx, TransferWallet.SENDING); + } catch (e: any) { + this.throwParsedError(e); + } + } + + async getCurrentOutboundCapacity(): Promise { + return (await this.nttManager.getCurrentOutboundCapacity()).toString(); + } + + async getCurrentInboundCapacity( + fromChain: ChainName | ChainId, + ): Promise { + return ( + await this.nttManager.getCurrentInboundCapacity(toChainId(fromChain)) + ).toString(); + } + + async getRateLimitDuration(): Promise { + return (await this.nttManager.rateLimitDuration()).toNumber(); + } + + async getInboundQueuedTransfer( + messageDigest: string, + ): Promise { + const queuedTransfer = await this.nttManager.getInboundQueuedTransfer( + messageDigest, + ); + if (queuedTransfer.txTimestamp.gt(0)) { + const { recipient, amount, txTimestamp } = queuedTransfer; + const duration = await this.getRateLimitDuration(); + return { + recipient: config.wh.parseAddress(recipient, this.chain), + amount: amount.toString(), + rateLimitExpiryTimestamp: txTimestamp.add(duration).toNumber(), + }; + } + return undefined; + } + + async completeInboundQueuedTransfer( + messageDigest: string, + recipient: string, + payer: string, + ): Promise { + try { + const tx = + await this.nttManager.populateTransaction.completeInboundQueuedTransfer( + messageDigest, + ); + return await this.signAndSendTransaction(tx, TransferWallet.RECEIVING); + } catch (e) { + this.throwParsedError(e); + } + } + + // The transfer is "complete" when the message is executed and not inbound queued + async isTransferCompleted(messageDigest: string): Promise { + const isMessageExecuted = await this.nttManager.isMessageExecuted( + messageDigest, + ); + if (isMessageExecuted) { + const queuedTransfer = await this.getInboundQueuedTransfer(messageDigest); + return !queuedTransfer; + } + return false; + } + + async isPaused(): Promise { + return await this.nttManager.isPaused(); + } + + async fetchRedeemTx(messageDigest: string): Promise { + const eventFilter = this.nttManager.filters.TransferRedeemed(messageDigest); + const provider = config.wh.mustGetProvider(this.chain); + const currentBlock = await provider.getBlockNumber(); + const chainName = toChainName(this.chain); + const chainConfig = config.chains[chainName]!; + const events = await this.nttManager.queryFilter( + eventFilter, + currentBlock - chainConfig.maxBlockSearch, + ); + return events?.[0]?.transactionHash || undefined; + } + + throwParsedError(e: any): never { + const message = tryParseErrorMessage(this.nttManager.interface, e); + if (message === 'InboundQueuedTransferNotFound') { + throw new InboundQueuedTransferNotFoundError(); + } + if (message === 'InboundQueuedTransferStillQueued') { + throw new InboundQueuedTransferStillQueuedError(); + } + if (message === 'RequireContractIsNotPaused') { + throw new ContractIsPausedError(); + } + if (message === 'NotEnoughCapacity') { + throw new NotEnoughCapacityError(); + } + throw e; + } +} diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/wormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/platforms/evm/wormholeTransceiver.ts new file mode 100644 index 000000000..9e8bc4823 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/evm/wormholeTransceiver.ts @@ -0,0 +1,46 @@ +import { ChainId, ChainName } from '@wormhole-foundation/wormhole-connect-sdk'; +import { WormholeTransceiver__factory } from './abis/WormholeTransceiver__factory'; +import { TransferWallet, signAndSendTransaction } from 'utils/wallet'; +import { WormholeTransceiver as WormholeTransceiverAbi } from './abis/WormholeTransceiver'; +import config from 'config'; +import { toChainId, toChainName } from 'utils/sdk'; + +export class WormholeTransceiver { + readonly transceiver: WormholeTransceiverAbi; + + constructor(readonly chain: ChainName | ChainId, address: string) { + this.transceiver = WormholeTransceiver__factory.connect( + address, + config.wh.mustGetProvider(chain), + ); + } + + async isWormholeRelayingEnabled( + destChain: ChainName | ChainId, + ): Promise { + return await this.transceiver.isWormholeRelayingEnabled( + toChainId(destChain), + ); + } + + async isSpecialRelayingEnabled( + destChain: ChainName | ChainId, + ): Promise { + return await this.transceiver.isSpecialRelayingEnabled( + toChainId(destChain), + ); + } + + async receiveMessage(vaa: string, payer: string): Promise { + const tx = await this.transceiver.populateTransaction.receiveMessage(vaa); + const signer = await config.wh.mustGetSigner(this.chain); + const response = await signer.sendTransaction(tx); + const receipt = await response.wait(); + const txId = await signAndSendTransaction( + toChainName(this.chain), + receipt, + TransferWallet.RECEIVING, + ); + return txId; + } +} diff --git a/wormhole-connect/src/routes/ntt/platforms/index.ts b/wormhole-connect/src/routes/ntt/platforms/index.ts new file mode 100644 index 000000000..180df6b7b --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/index.ts @@ -0,0 +1,17 @@ +import { ChainName, ChainId } from '@wormhole-foundation/wormhole-connect-sdk'; +import { isEvmChain, toChainName } from 'utils/sdk'; +import { NttManagerEvm } from './evm'; +import { NttManagerSolana } from './solana'; + +export const getNttManager = ( + chain: ChainName | ChainId, + nttManagerAddress: string, +) => { + if (isEvmChain(chain)) { + return new NttManagerEvm(chain, nttManagerAddress); + } + if (toChainName(chain) === 'solana') { + return new NttManagerSolana(nttManagerAddress); + } + throw new Error(`Unsupported chain: ${chain}`); +}; diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts b/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts new file mode 100644 index 000000000..31b651e5d --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts @@ -0,0 +1,105 @@ +import { solanaContext } from 'utils/sdk'; +import { PostedMessageData } from '@certusone/wormhole-sdk/lib/esm/solana/wormhole'; +import { hexlify } from 'ethers/lib/utils'; +import { NttRelayingType, UnsignedNttMessage } from 'routes/types'; +import { getNttToken } from 'store/transferInput'; +import { getTokenById, getTokenDecimals } from 'utils'; +import { + getNttManagerMessageDigest, + parseWormholeTransceiverMessage, +} from 'routes/ntt/utils'; +import config from 'config'; + +export const getMessageSolana = async ( + tx: string, +): Promise => { + const context = solanaContext(); + const connection = context.connection; + if (!connection) throw new Error('Connection not found'); + const response = await connection.getTransaction(tx, { + maxSupportedTransactionVersion: 0, + }); + if (!response) throw new Error('Transaction not found'); + const core = config.wh.mustGetContracts('solana').core; + const accounts = response.transaction.message.getAccountKeys(); + const wormholeIx = response.meta?.innerInstructions + ?.flatMap((ix) => ix.instructions) + .find((ix) => accounts?.get(ix.programIdIndex)?.toString() === core); + if (!wormholeIx) throw new Error('Wormhole instruction not found'); + const wormholeMessageAccountKey = accounts?.get(wormholeIx.accounts[1]); + if (!wormholeMessageAccountKey) throw new Error('Message account not found'); + const wormholeMessageAccount = await connection.getAccountInfo( + wormholeMessageAccountKey, + ); + if (wormholeMessageAccount === null) { + throw new Error('wormhole message account not found'); + } + const messageData = PostedMessageData.deserialize( + wormholeMessageAccount.data, + ); + const transceiverMessage = parseWormholeTransceiverMessage( + messageData.message.payload, + ); + const nttManagerMessage = transceiverMessage.nttManagerPayload; + const fromChain = config.wh.toChainName('solana'); + const toChain = config.wh.toChainName( + nttManagerMessage.payload.recipientChain, + ); + const tokenAddress = config.wh.parseAddress( + hexlify(nttManagerMessage.payload.sourceToken), + fromChain, + ); + const tokenId = { + chain: fromChain, + address: tokenAddress, + }; + const token = getTokenById(tokenId); + if (!token?.ntt) { + throw new Error(`Token ${tokenId} not found`); + } + const receivedTokenKey = getNttToken(token.ntt.groupId, toChain); + if (!receivedTokenKey) { + throw new Error(`Received token key not found for ${tokenId}`); + } + const logMsgs = response.meta?.logMessages || []; + const regex = /total fee in lamports: (\d+)/; + const relayerFeeMsg = logMsgs.find((msg) => regex.test(msg)); + const relayerFee = relayerFeeMsg ? regex.exec(relayerFeeMsg)?.[1] : ''; + return { + sendTx: tx, + sender: config.wh.parseAddress( + hexlify(nttManagerMessage.sender), + fromChain, + ), + amount: nttManagerMessage.payload.trimmedAmount.amount.toString(), + payloadID: 0, + recipient: config.wh.parseAddress( + hexlify(nttManagerMessage.payload.recipientAddress), + toChain, + ), + toChain, + fromChain, + tokenAddress: config.wh.parseAddress( + hexlify(nttManagerMessage.payload.sourceToken), + fromChain, + ), + tokenChain: token.nativeChain, + tokenId, + tokenKey: token.key, + tokenDecimals: getTokenDecimals(config.wh.toChainId(fromChain), tokenId), + receivedTokenKey, + emitterAddress: hexlify( + context.formatAddress(messageData.message.emitterAddress), + ), + sequence: messageData.message.sequence.toString(), + block: response.slot, + gasFee: response.meta?.fee.toString(), + recipientNttManager: config.wh.parseAddress( + hexlify(transceiverMessage.recipientNttManager), + toChain, + ), + messageDigest: getNttManagerMessageDigest(fromChain, nttManagerMessage), + relayerFee: relayerFee || '', + relayingType: relayerFee ? NttRelayingType.Special : NttRelayingType.Manual, + }; +}; diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/index.ts b/wormhole-connect/src/routes/ntt/platforms/solana/index.ts new file mode 100644 index 000000000..6a3c0bbfd --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/solana/index.ts @@ -0,0 +1,2 @@ +export * from './nttManager'; +export * from './getMessage'; diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts b/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts new file mode 100644 index 000000000..6bea6dc51 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts @@ -0,0 +1,788 @@ +import { + addComputeBudget, + ChainId, + ChainName, + TokenId, +} from '@wormhole-foundation/wormhole-connect-sdk'; +import { InboundQueuedTransfer } from '../../types'; +import { solanaContext, toChainId, toChainName } from 'utils/sdk'; +import { TransferWallet, postVaa, signAndSendTransaction } from 'utils/wallet'; +import { + Connection, + Keypair, + PublicKey, + Transaction, + TransactionInstruction, +} from '@solana/web3.js'; +import { + createApproveInstruction, + getAssociatedTokenAddressSync, + createAssociatedTokenAccountInstruction, +} from '@solana/spl-token'; +import { BN, IdlAccounts, Program } from '@coral-xyz/anchor'; +import { SignedVaa, parseVaa } from '@certusone/wormhole-sdk/lib/esm'; +import { utils } from 'ethers'; +import { + getNttManagerMessageDigest, + parseWormholeTransceiverMessage, +} from 'routes/ntt/utils'; +import { + ExampleNativeTokenTransfers, + IDL, +} from './types/example_native_token_transfers'; +import { + derivePostedVaaKey, + getWormholeDerivedAccounts, +} from '@certusone/wormhole-sdk/lib/esm/solana/wormhole'; +import { associatedAddress } from '@coral-xyz/anchor/dist/cjs/utils/token'; +import { NttQuoter } from './nttQuoter'; +import { getTokenById } from 'utils'; +import { Keccak } from 'sha3'; +import CONFIG from 'config'; + +// TODO: make sure this is in sync with the contract +const RATE_LIMIT_DURATION = 24 * 60 * 60; + +type Config = IdlAccounts['config']; +type InboxItem = IdlAccounts['inboxItem']; +type OutboxRateLimit = + IdlAccounts['outboxRateLimit']; +type InboxRateLimit = + IdlAccounts['inboxRateLimit']; + +interface TransferArgs { + amount: BN; + recipientChain: { id: ChainId }; + recipientAddress: number[]; + shouldQueue: boolean; +} + +export class NttManagerSolana { + readonly connection: Connection; + readonly program: Program; + readonly wormholeId: string; + + constructor(readonly nttId: string) { + const { connection } = solanaContext(); + if (!connection) throw new Error('Connection not found'); + this.connection = connection; + this.program = new Program(IDL, nttId, { connection }); + const core = CONFIG.wh.mustGetContracts('solana').core; + if (!core) throw new Error('Core not found'); + this.wormholeId = core; + } + + async send( + token: TokenId, + sender: string, + recipient: string, + amount: bigint, + toChain: ChainName | ChainId, + shouldSkipRelayerSend: boolean, + ): Promise { + const config = await this.getConfig(); + const outboxItem = Keypair.generate(); + const destContext = CONFIG.wh.getContext(toChain); + const payer = new PublicKey(sender); + const tokenAccount = getAssociatedTokenAddressSync( + new PublicKey(token.address), + payer, + ); + const txArgs = { + payer, + from: tokenAccount, + amount: new BN(amount.toString()), + recipientChain: toChainName(toChain), + recipientAddress: destContext.formatAddress(recipient), + fromAuthority: payer, + outboxItem: outboxItem.publicKey, + config, + shouldQueue: false, // revert instead of getting queued + }; + let transferIx; + if (config.mode.locking) { + transferIx = await this.createTransferLockInstruction(txArgs); + } else { + transferIx = await this.createTransferBurnInstruction(txArgs); + } + const releaseIx = await this.createReleaseOutboundInstruction({ + payer, + outboxItem: outboxItem.publicKey, + revertOnDelay: !txArgs.shouldQueue, + }); + const transferArgs: TransferArgs = { + amount: txArgs.amount, + recipientChain: { id: toChainId(txArgs.recipientChain) }, + recipientAddress: Array.from(txArgs.recipientAddress), + shouldQueue: txArgs.shouldQueue, + }; + const approveIx = createApproveInstruction( + tokenAccount, + this.sessionAuthorityAddress(txArgs.fromAuthority, transferArgs), + payer, + BigInt(amount.toString()), + ); + const tx = new Transaction(); + tx.add(approveIx, transferIx, releaseIx); + if (!shouldSkipRelayerSend) { + const { ntt } = getTokenById(token) || {}; + if (!ntt?.solanaQuoter) { + throw new Error(`no solana quoter for token: ${token}`); + } + const quoter = new NttQuoter(ntt.solanaQuoter); + const fee = await quoter.calcRelayCost(toChain); + const relayIx = await quoter.createRequestRelayInstruction( + payer, + outboxItem.publicKey, + toChain, + fee, + ); + tx.add(relayIx); + } + tx.feePayer = payer; + const { blockhash } = await this.connection.getLatestBlockhash('finalized'); + tx.recentBlockhash = blockhash; + await addComputeBudget(this.connection, tx); + tx.partialSign(outboxItem); + const txId = await signAndSendTransaction( + 'solana', + tx, + TransferWallet.SENDING, + { commitment: 'finalized' }, + ); + return txId; + } + + async receiveMessage(vaa: string, payer: string): Promise { + const core = CONFIG.wh.mustGetContracts('solana').core; + if (!core) throw new Error('Core not found'); + const config = await this.getConfig(); + const vaaArray = utils.arrayify(vaa, { allowMissingPrefix: true }); + const payerPublicKey = new PublicKey(payer); + const redeemArgs = { + payer: payerPublicKey, + vaa: vaaArray, + config, + }; + const parsedVaa = parseVaa(vaaArray); + const chainId = toChainId(parsedVaa.emitterChain as ChainId); + // First post the VAA + await postVaa(this.connection, core, Buffer.from(vaaArray)); + const tx = new Transaction(); + // Create the ATA if it doesn't exist + const mint = await this.mintAccountAddress(config); + const ata = getAssociatedTokenAddressSync(mint, payerPublicKey); + if (!(await this.connection.getAccountInfo(ata))) { + const createAtaIx = createAssociatedTokenAccountInstruction( + payerPublicKey, + ata, + payerPublicKey, + mint, + ); + tx.add(createAtaIx); + } + // Here we create a transaction with three instructions: + // 1. receive wormhole message (vaa) + // 2. redeem + // 3. releaseInboundMint or releaseInboundUnlock (depending on mode) + // + // The first instruction verifies the VAA. + // The second instruction places the transfer in the inbox, then the third instruction + // releases it. + // + // In case the redeemed amount exceeds the remaining inbound rate limit capacity, + // the transaction gets delayed. If this happens, the second instruction will not actually + // be able to release the transfer yet. + // To make sure the transaction still succeeds, we set revertOnDelay to false, which will + // just make the second instruction a no-op in case the transfer is delayed. + tx.add(await this.createReceiveWormholeMessageInstruction(redeemArgs)); + tx.add(await this.createRedeemInstruction(redeemArgs)); + const { nttManagerPayload } = parseWormholeTransceiverMessage( + parsedVaa.payload, + ); + const messageDigest = getNttManagerMessageDigest( + chainId, + nttManagerPayload, + ); + const releaseArgs = { + ...redeemArgs, + messageDigest, + recipient: new PublicKey(nttManagerPayload.payload.recipientAddress), + chain: chainId, + revertOnDelay: false, + }; + if (config.mode.locking) { + tx.add(await this.createReleaseInboundUnlockInstruction(releaseArgs)); + } else { + tx.add(await this.createReleaseInboundMintInstruction(releaseArgs)); + } + tx.feePayer = payerPublicKey; + const { blockhash } = await this.connection.getLatestBlockhash('finalized'); + tx.recentBlockhash = blockhash; + await addComputeBudget(this.connection, tx); + const txId = await signAndSendTransaction( + 'solana', + tx, + TransferWallet.RECEIVING, + { commitment: 'finalized' }, + ); + return txId; + } + + async getCurrentOutboundCapacity(): Promise { + const { + rateLimit: { limit, capacityAtLastTx, lastTxTimestamp }, + } = await this.getOutboxRateLimit(); + return await this.getCurrentCapacity( + limit, + capacityAtLastTx, + lastTxTimestamp, + ); + } + + async getCurrentInboundCapacity( + fromChain: ChainName | ChainId, + ): Promise { + const { + rateLimit: { limit, capacityAtLastTx, lastTxTimestamp }, + } = await this.getInboxRateLimit(fromChain); + return await this.getCurrentCapacity( + limit, + capacityAtLastTx, + lastTxTimestamp, + ); + } + + async getCurrentCapacity( + limit: BN, + capacityAtLastTx: BN, + lastTxTimestamp: BN, + ) { + const timePassed = BN.max( + new BN(Date.now() / 1000).sub(lastTxTimestamp), + new BN(0), + ); + const duration = await this.getRateLimitDuration(); + const calculatedCapacity = capacityAtLastTx.add( + timePassed.mul(limit).div(new BN(duration)), + ); + return calculatedCapacity.lt(limit) + ? calculatedCapacity.toString() + : limit.toString(); + } + + async getRateLimitDuration(): Promise { + // TODO: how will solana implement this? + // const config = await this.getConfig(); + // return config.rateLimitDuration.toNumber(); + return RATE_LIMIT_DURATION; + } + + async getInboundQueuedTransfer( + messageDigest: string, + ): Promise { + let inboxItem; + try { + inboxItem = await this.getInboxItem(messageDigest); + } catch (e: any) { + if (e.message?.includes('Account does not exist')) { + return undefined; + } + throw e; + } + if (inboxItem.releaseStatus.releaseAfter) { + return { + recipient: inboxItem.recipientAddress.toString(), + amount: inboxItem.amount.toString(), + rateLimitExpiryTimestamp: + inboxItem.releaseStatus.releaseAfter[0].toNumber(), + }; + } + return undefined; + } + + async completeInboundQueuedTransfer( + messageDigest: string, + recipientAddress: string, + payer: string, + ): Promise { + const payerPublicKey = new PublicKey(payer); + const releaseArgs = { + payer: payerPublicKey, + messageDigest, + recipient: new PublicKey(recipientAddress), + revertOnDelay: false, + }; + const config = await this.getConfig(); + const tx = new Transaction(); + // Create the ATA if it doesn't exist + const mint = await this.mintAccountAddress(config); + const ata = getAssociatedTokenAddressSync(mint, payerPublicKey); + if (!(await this.connection.getAccountInfo(ata))) { + const createAtaIx = createAssociatedTokenAccountInstruction( + payerPublicKey, + ata, + payerPublicKey, + mint, + ); + tx.add(createAtaIx); + } + if (config.mode.locking) { + tx.add(await this.createReleaseInboundUnlockInstruction(releaseArgs)); + } else { + tx.add(await this.createReleaseInboundMintInstruction(releaseArgs)); + } + tx.feePayer = payerPublicKey; + const { blockhash } = await this.connection.getLatestBlockhash('finalized'); + tx.recentBlockhash = blockhash; + await addComputeBudget(this.connection, tx); + const txId = await signAndSendTransaction( + 'solana', + tx, + TransferWallet.RECEIVING, + { commitment: 'finalized' }, + ); + return txId; + } + + async isTransferCompleted(messageDigest: string): Promise { + try { + const inboxItem = await this.getInboxItem(messageDigest); + return !!inboxItem.releaseStatus.released; + } catch (e: any) { + if (e.message?.includes('Account does not exist')) { + return false; + } + throw e; + } + } + + async fetchRedeemTx(messageDigest: string): Promise { + const address = await this.inboxItemAccountAddress(messageDigest); + // fetch the most recent signature + const signatures = await this.connection.getSignaturesForAddress(address, { + limit: 1, + }); + return signatures?.[0]?.signature; + } + + // Account addresses + + derivePda(seeds: Buffer | Array): PublicKey { + const seedsArray = seeds instanceof Buffer ? [seeds] : seeds; + const [address] = PublicKey.findProgramAddressSync( + seedsArray, + this.program.programId, + ); + return address; + } + + configAccountAddress(): PublicKey { + return this.derivePda(Buffer.from('config')); + } + + outboxRateLimitAccountAddress(): PublicKey { + return this.derivePda(Buffer.from('outbox_rate_limit')); + } + + inboxRateLimitAccountAddress(chain: ChainName | ChainId): PublicKey { + const chainId = toChainId(chain); + return this.derivePda([ + Buffer.from('inbox_rate_limit'), + new BN(chainId).toBuffer('be', 2), + ]); + } + + inboxItemAccountAddress(messageDigest: string): PublicKey { + return this.derivePda([ + Buffer.from('inbox_item'), + Buffer.from(messageDigest.slice(2), 'hex'), + ]); + } + + sessionAuthorityAddress(sender: PublicKey, args: TransferArgs): PublicKey { + const { amount, recipientChain, recipientAddress, shouldQueue } = args; + const serialized = Buffer.concat([ + amount.toArrayLike(Buffer, 'be', 8), + Buffer.from(new BN(recipientChain.id).toArrayLike(Buffer, 'be', 2)), + Buffer.from(new Uint8Array(recipientAddress)), + Buffer.from([shouldQueue ? 1 : 0]), + ]); + const hasher = new Keccak(256); + hasher.update(serialized); + return this.derivePda([ + Buffer.from('session_authority'), + sender.toBytes(), + hasher.digest(), + ]); + } + + tokenAuthorityAddress(): PublicKey { + return this.derivePda([Buffer.from('token_authority')]); + } + + emitterAccountAddress(): PublicKey { + return this.derivePda([Buffer.from('emitter')]); + } + + wormholeMessageAccountAddress(outboxItem: PublicKey): PublicKey { + return this.derivePda([Buffer.from('message'), outboxItem.toBuffer()]); + } + + peerAccountAddress(chain: ChainName | ChainId): PublicKey { + const chainId = toChainId(chain); + return this.derivePda([ + Buffer.from('peer'), + new BN(chainId).toBuffer('be', 2), + ]); + } + + transceiverPeerAccountAddress(chain: ChainName | ChainId): PublicKey { + const chainId = toChainId(chain); + return this.derivePda([ + Buffer.from('transceiver_peer'), + new BN(chainId).toBuffer('be', 2), + ]); + } + + transceiverMessageAccountAddress( + chain: ChainName | ChainId, + id: Buffer, + ): PublicKey { + const chainId = toChainId(chain); + if (id.length !== 32) { + throw new Error('id must be 32 bytes'); + } + return this.derivePda([ + Buffer.from('transceiver_message'), + new BN(chainId).toBuffer('be', 2), + id, + ]); + } + + registeredTransceiverAddress(transceiver: PublicKey): PublicKey { + return this.derivePda([ + Buffer.from('registered_transceiver'), + transceiver.toBuffer(), + ]); + } + + // Instructions + + /** + * Creates a transfer_burn instruction. The `payer` and `fromAuthority` + * arguments must sign the transaction + */ + async createTransferBurnInstruction(args: { + payer: PublicKey; + from: PublicKey; + fromAuthority: PublicKey; + amount: BN; + recipientChain: ChainName; + recipientAddress: ArrayLike; + outboxItem: PublicKey; + shouldQueue: boolean; + config?: Config; + }): Promise { + const config = await this.getConfig(args.config); + const chainId = toChainId(args.recipientChain); + const mint = await this.mintAccountAddress(config); + const transferArgs: TransferArgs = { + amount: args.amount, + recipientChain: { id: chainId }, + recipientAddress: Array.from(args.recipientAddress), + shouldQueue: args.shouldQueue, + }; + return await this.program.methods + .transferBurn({ + amount: args.amount, + recipientChain: { id: chainId }, + recipientAddress: Array.from(args.recipientAddress), + shouldQueue: args.shouldQueue, + }) + .accounts({ + common: { + payer: args.payer, + config: { config: this.configAccountAddress() }, + mint, + from: args.from, + outboxItem: args.outboxItem, + outboxRateLimit: this.outboxRateLimitAccountAddress(), + }, + peer: this.peerAccountAddress(args.recipientChain), + inboxRateLimit: this.inboxRateLimitAccountAddress(args.recipientChain), + sessionAuthority: this.sessionAuthorityAddress( + args.fromAuthority, + transferArgs, + ), + }) + .instruction(); + } + + /** + * Creates a transfer_lock instruction. The `payer`, `fromAuthority`, and `outboxItem` + * arguments must sign the transaction + */ + async createTransferLockInstruction(args: { + payer: PublicKey; + from: PublicKey; + fromAuthority: PublicKey; + amount: BN; + recipientChain: ChainName; + recipientAddress: ArrayLike; + shouldQueue: boolean; + outboxItem: PublicKey; + config: Config; + }): Promise { + const chainId = toChainId(args.recipientChain); + const mint = await this.mintAccountAddress(args.config); + const transferArgs: TransferArgs = { + amount: args.amount, + recipientChain: { id: chainId }, + recipientAddress: Array.from(args.recipientAddress), + shouldQueue: args.shouldQueue, + }; + return await this.program.methods + .transferLock({ + amount: args.amount, + recipientChain: { id: chainId }, + recipientAddress: Array.from(args.recipientAddress), + shouldQueue: args.shouldQueue, + }) + .accounts({ + common: { + payer: args.payer, + config: { config: this.configAccountAddress() }, + mint, + from: args.from, + tokenProgram: await this.tokenProgram(args.config), + outboxItem: args.outboxItem, + outboxRateLimit: this.outboxRateLimitAccountAddress(), + }, + peer: this.peerAccountAddress(args.recipientChain), + inboxRateLimit: this.inboxRateLimitAccountAddress(args.recipientChain), + custody: await this.custodyAccountAddress(args.config), + sessionAuthority: this.sessionAuthorityAddress( + args.fromAuthority, + transferArgs, + ), + }) + .instruction(); + } + + /** + * Creates a release_outbound instruction. The `payer` needs to sign the transaction. + */ + async createReleaseOutboundInstruction(args: { + payer: PublicKey; + outboxItem: PublicKey; + revertOnDelay: boolean; + }): Promise { + const whAccs = getWormholeDerivedAccounts( + this.program.programId, + this.wormholeId, + ); + return await this.program.methods + .releaseWormholeOutbound({ + revertOnDelay: args.revertOnDelay, + }) + .accounts({ + payer: args.payer, + config: { config: this.configAccountAddress() }, + outboxItem: args.outboxItem, + wormholeMessage: this.wormholeMessageAccountAddress(args.outboxItem), + emitter: whAccs.wormholeEmitter, + transceiver: this.registeredTransceiverAddress(this.program.programId), + wormhole: { + bridge: whAccs.wormholeBridge, + feeCollector: whAccs.wormholeFeeCollector, + sequence: whAccs.wormholeSequence, + program: this.wormholeId, + }, + }) + .instruction(); + } + + async createReleaseInboundMintInstruction(args: { + payer: PublicKey; + messageDigest: string; + revertOnDelay: boolean; + recipient: PublicKey; + config?: Config; + }): Promise { + const config = await this.getConfig(args.config); + const mint = await this.mintAccountAddress(config); + return await this.program.methods + .releaseInboundMint({ + revertOnDelay: args.revertOnDelay, + }) + .accounts({ + common: { + payer: args.payer, + config: { config: this.configAccountAddress() }, + inboxItem: this.inboxItemAccountAddress(args.messageDigest), + recipient: getAssociatedTokenAddressSync(mint, args.recipient), + mint, + tokenAuthority: this.tokenAuthorityAddress(), + }, + }) + .instruction(); + } + + async createReleaseInboundUnlockInstruction(args: { + payer: PublicKey; + messageDigest: string; + revertOnDelay: boolean; + recipient: PublicKey; + config?: Config; + }): Promise { + const config = await this.getConfig(args.config); + const mint = await this.mintAccountAddress(config); + return await this.program.methods + .releaseInboundUnlock({ + revertOnDelay: args.revertOnDelay, + }) + .accounts({ + common: { + payer: args.payer, + config: { config: this.configAccountAddress() }, + inboxItem: this.inboxItemAccountAddress(args.messageDigest), + recipient: getAssociatedTokenAddressSync(mint, args.recipient), + mint, + tokenAuthority: this.tokenAuthorityAddress(), + }, + custody: await this.custodyAccountAddress(config), + }) + .instruction(); + } + + async createReceiveWormholeMessageInstruction(args: { + payer: PublicKey; + vaa: SignedVaa; + config?: Config; + }): Promise { + const parsedVaa = parseVaa(args.vaa); + const { nttManagerPayload } = parseWormholeTransceiverMessage( + parsedVaa.payload, + ); + const chainId = toChainId(parsedVaa.emitterChain as ChainId); + const transceiverPeer = this.transceiverPeerAccountAddress(chainId); + return await this.program.methods + .receiveWormholeMessage() + .accounts({ + payer: args.payer, + config: this.configAccountAddress(), + peer: transceiverPeer, + vaa: derivePostedVaaKey(this.wormholeId, parseVaa(args.vaa).hash), + transceiverMessage: this.transceiverMessageAccountAddress( + chainId, + nttManagerPayload.id, + ), + }) + .instruction(); + } + + async createRedeemInstruction(args: { + payer: PublicKey; + vaa: SignedVaa; + config?: Config; + }): Promise { + const config = await this.getConfig(args.config); + const parsedVaa = parseVaa(args.vaa); + const { nttManagerPayload } = parseWormholeTransceiverMessage( + parsedVaa.payload, + ); + const chainId = toChainId(parsedVaa.emitterChain as ChainId); + const messageDigest = getNttManagerMessageDigest( + chainId, + nttManagerPayload, + ); + const nttManagerPeer = this.peerAccountAddress(chainId); + const inboxRateLimit = this.inboxRateLimitAccountAddress(chainId); + return await this.program.methods + .redeem({}) + .accounts({ + payer: args.payer, + config: this.configAccountAddress(), + peer: nttManagerPeer, + transceiverMessage: this.transceiverMessageAccountAddress( + chainId, + nttManagerPayload.id, + ), + transceiver: this.registeredTransceiverAddress(this.program.programId), + mint: await this.mintAccountAddress(config), + inboxItem: this.inboxItemAccountAddress(messageDigest), + inboxRateLimit, + outboxRateLimit: this.outboxRateLimitAccountAddress(), + }) + .instruction(); + } + + // Account access + + /** + * Fetches the Config account from the contract. + * + * @param config If provided, the config is just returned without making a + * network request. This is handy in case multiple config + * accessor functions are used, the config can just be queried + * once and passed around. + */ + async getConfig(config?: Config): Promise { + return ( + config ?? + (await this.program.account.config.fetch(this.configAccountAddress())) + ); + } + + async isPaused(config?: Config): Promise { + return (await this.getConfig(config)).paused; + } + + async mintAccountAddress(config?: Config): Promise { + return (await this.getConfig(config)).mint; + } + + async tokenProgram(config?: Config): Promise { + return (await this.getConfig(config)).tokenProgram; + } + + async getInboxItem(messageDigest: string): Promise { + return await this.program.account.inboxItem.fetch( + this.inboxItemAccountAddress(messageDigest), + ); + } + + async getOutboxRateLimit(): Promise { + return await this.program.account.outboxRateLimit.fetch( + this.outboxRateLimitAccountAddress(), + ); + } + + async getInboxRateLimit(chain: ChainName | ChainId): Promise { + return await this.program.account.inboxRateLimit.fetch( + this.inboxRateLimitAccountAddress(chain), + ); + } + + /** + * Returns the address of the custody account. If the config is available + * (i.e. the program is initialized), the mint is derived from the config. + * Otherwise, the mint must be provided. + */ + async custodyAccountAddress( + configOrMint: Config | PublicKey, + ): Promise { + if (configOrMint instanceof PublicKey) { + return associatedAddress({ + mint: configOrMint, + owner: this.tokenAuthorityAddress(), + }); + } else { + return associatedAddress({ + mint: await this.mintAccountAddress(configOrMint), + owner: this.tokenAuthorityAddress(), + }); + } + } +} diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/nttQuoter.ts b/wormhole-connect/src/routes/ntt/platforms/solana/nttQuoter.ts new file mode 100644 index 000000000..d7ea901ba --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/solana/nttQuoter.ts @@ -0,0 +1,154 @@ +import { ChainName, ChainId } from '@wormhole-foundation/wormhole-connect-sdk'; +import { + PublicKeyInitData, + PublicKey, + SystemProgram, + LAMPORTS_PER_SOL, + Connection, +} from '@solana/web3.js'; +import { BN, Program } from '@coral-xyz/anchor'; +import { NttQuoter as NttQuoterType, IDL } from './types/ntt_quoter'; +import { solanaContext, toChainId } from 'utils/sdk'; + +//constants that must match ntt-quoter lib.rs / implementation: +const EVM_GAS_COST = 250_000; // TODO: make sure this is right +const USD_UNIT = 1e6; +const WEI_PER_GWEI = 1e9; +const GWEI_PER_ETH = 1e9; +const SEED_PREFIX_INSTANCE = 'instance'; +const SEED_PREFIX_REGISTERED_CHAIN = 'registered_chain'; +const SEED_PREFIX_RELAY_REQUEST = 'relay_request'; + +const U64 = { + MAX: new BN((2n ** 64n - 1n).toString()), + to: (amount: number, unit: number) => { + const ret = new BN(Math.round(amount * unit)); + + if (ret.isNeg()) throw new Error('Value negative'); + + if (ret.bitLength() > 64) throw new Error('Value too large'); + + return ret; + }, + from: (amount: BN, unit: number) => amount.toNumber() / unit, +}; + +export class NttQuoter { + readonly connection: Connection; + readonly program: Program; + readonly instance: PublicKey; + + constructor(programId: PublicKeyInitData) { + const { connection } = solanaContext(); + if (!connection) throw new Error('Connection not found'); + this.connection = connection; + this.program = new Program(IDL, new PublicKey(programId), { + connection, + }); + this.instance = this.derivePda(Buffer.from(SEED_PREFIX_INSTANCE)); + } + + async isRelayEnabled(destChain: ChainName | ChainId) { + try { + const { paused } = await this.getRegisteredChain(destChain); + return !paused; + } catch (e: any) { + if (e.message?.includes('Account does not exist')) { + return false; + } + throw e; + } + } + + async calcRelayCost(chain: ChainName | ChainId) { + const [chainData, instanceData, rentCost] = await Promise.all([ + this.getRegisteredChain(chain), + this.getInstance(), + this.program.provider.connection.getMinimumBalanceForRentExemption( + this.program.account.relayRequest.size, + ), + ]); + + const totalNativeGasCostUsd = + chainData.nativePriceUsd * + ((chainData.gasPriceGwei * EVM_GAS_COST) / GWEI_PER_ETH); + + const totalCostSol = + rentCost / LAMPORTS_PER_SOL + + (chainData.basePriceUsd + totalNativeGasCostUsd) / + instanceData.solPriceUsd; + + // Add 5% to account for possible price updates while the tx is in flight + const cost = U64.to(totalCostSol * 1.05, LAMPORTS_PER_SOL); + return cost; + } + + async createRequestRelayInstruction( + payer: PublicKey, + outboxItem: PublicKey, + chain: ChainName | ChainId, + maxFee: BN, + ) { + return this.program.methods + .requestRelay({ + maxFee, + gasDropoff: new BN(0), + }) + .accounts({ + payer, + instance: this.instance, + registeredChain: this.registeredChainPda(toChainId(chain)), + outboxItem, + relayRequest: this.relayRequestPda(outboxItem), + systemProgram: SystemProgram.programId, + }) + .instruction(); + } + + async getInstance() { + const data = await this.program.account.instance.fetch(this.instance); + return { + owner: data.owner, + assistant: data.assistant, + feeRecipient: data.feeRecipient, + solPriceUsd: U64.from(data.solPrice, USD_UNIT), + }; + } + + async getRegisteredChain(chain: ChainName | ChainId) { + const data = await this.program.account.registeredChain.fetch( + this.registeredChainPda(toChainId(chain)), + ); + + return { + paused: data.basePrice.eq(U64.MAX), + maxGasDropoffEth: U64.from(data.maxGasDropoff, GWEI_PER_ETH), + basePriceUsd: U64.from(data.basePrice, USD_UNIT), + nativePriceUsd: U64.from(data.nativePrice, USD_UNIT), + gasPriceGwei: U64.from(data.gasPrice, WEI_PER_GWEI), + }; + } + + private registeredChainPda(chainId: number) { + return this.derivePda([ + Buffer.from(SEED_PREFIX_REGISTERED_CHAIN), + new BN(chainId).toBuffer('be', 2), + ]); + } + + private relayRequestPda(outboxItem: PublicKey) { + return this.derivePda([ + Buffer.from(SEED_PREFIX_RELAY_REQUEST), + outboxItem.toBytes(), + ]); + } + + private derivePda(seeds: Buffer | Array): PublicKey { + const seedsArray = seeds instanceof Buffer ? [seeds] : seeds; + const [address] = PublicKey.findProgramAddressSync( + seedsArray, + this.program.programId, + ); + return address; + } +} diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/types/example_native_token_transfers.ts b/wormhole-connect/src/routes/ntt/platforms/solana/types/example_native_token_transfers.ts new file mode 100644 index 000000000..db8567df3 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/solana/types/example_native_token_transfers.ts @@ -0,0 +1,3341 @@ +export type ExampleNativeTokenTransfers = { + version: '0.1.0'; + name: 'example_native_token_transfers'; + instructions: [ + { + name: 'initialize'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'deployer'; + isMut: false; + isSigner: true; + }, + { + name: 'programData'; + isMut: false; + isSigner: false; + }, + { + name: 'config'; + isMut: true; + isSigner: false; + }, + { + name: 'mint'; + isMut: false; + isSigner: false; + }, + { + name: 'rateLimit'; + isMut: true; + isSigner: false; + }, + { + name: 'tokenAuthority'; + isMut: false; + isSigner: false; + }, + { + name: 'custody'; + isMut: true; + isSigner: false; + docs: [ + 'The custody account that holds tokens in locking mode.', + 'NOTE: the account is unconditionally initialized, but not used in', + 'burning mode.', + ]; + }, + { + name: 'tokenProgram'; + isMut: false; + isSigner: false; + docs: ['associated token account for the given mint.']; + }, + { + name: 'associatedTokenProgram'; + isMut: false; + isSigner: false; + }, + { + name: 'bpfLoaderUpgradeableProgram'; + isMut: false; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'InitializeArgs'; + }; + }, + ]; + }, + { + name: 'transferBurn'; + accounts: [ + { + name: 'common'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + accounts: [ + { + name: 'config'; + isMut: false; + isSigner: false; + }, + ]; + }, + { + name: 'mint'; + isMut: true; + isSigner: false; + }, + { + name: 'from'; + isMut: true; + isSigner: false; + docs: ['account can spend these tokens.']; + }, + { + name: 'tokenProgram'; + isMut: false; + isSigner: false; + }, + { + name: 'outboxItem'; + isMut: true; + isSigner: true; + }, + { + name: 'outboxRateLimit'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + }, + { + name: 'inboxRateLimit'; + isMut: true; + isSigner: false; + }, + { + name: 'peer'; + isMut: false; + isSigner: false; + }, + { + name: 'sessionAuthority'; + isMut: false; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'TransferArgs'; + }; + }, + ]; + }, + { + name: 'transferLock'; + accounts: [ + { + name: 'common'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + accounts: [ + { + name: 'config'; + isMut: false; + isSigner: false; + }, + ]; + }, + { + name: 'mint'; + isMut: true; + isSigner: false; + }, + { + name: 'from'; + isMut: true; + isSigner: false; + docs: ['account can spend these tokens.']; + }, + { + name: 'tokenProgram'; + isMut: false; + isSigner: false; + }, + { + name: 'outboxItem'; + isMut: true; + isSigner: true; + }, + { + name: 'outboxRateLimit'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + }, + { + name: 'inboxRateLimit'; + isMut: true; + isSigner: false; + }, + { + name: 'peer'; + isMut: false; + isSigner: false; + }, + { + name: 'sessionAuthority'; + isMut: false; + isSigner: false; + }, + { + name: 'custody'; + isMut: true; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'TransferArgs'; + }; + }, + ]; + }, + { + name: 'redeem'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + isMut: false; + isSigner: false; + }, + { + name: 'peer'; + isMut: false; + isSigner: false; + }, + { + name: 'transceiverMessage'; + isMut: false; + isSigner: false; + }, + { + name: 'transceiver'; + isMut: false; + isSigner: false; + }, + { + name: 'mint'; + isMut: false; + isSigner: false; + }, + { + name: 'inboxItem'; + isMut: true; + isSigner: false; + docs: [ + 'NOTE: This account is content-addressed (PDA seeded by the message hash).', + 'This is because in a multi-transceiver configuration, the different', + 'transceivers "vote" on messages (by delivering them). By making the inbox', + "items content-addressed, we can ensure that disagreeing votes don't", + 'interfere with each other.', + ]; + }, + { + name: 'inboxRateLimit'; + isMut: true; + isSigner: false; + }, + { + name: 'outboxRateLimit'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'RedeemArgs'; + }; + }, + ]; + }, + { + name: 'releaseInboundMint'; + accounts: [ + { + name: 'common'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + accounts: [ + { + name: 'config'; + isMut: false; + isSigner: false; + }, + ]; + }, + { + name: 'inboxItem'; + isMut: true; + isSigner: false; + }, + { + name: 'recipient'; + isMut: true; + isSigner: false; + }, + { + name: 'tokenAuthority'; + isMut: false; + isSigner: false; + }, + { + name: 'mint'; + isMut: true; + isSigner: false; + }, + { + name: 'tokenProgram'; + isMut: false; + isSigner: false; + }, + ]; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'ReleaseInboundArgs'; + }; + }, + ]; + }, + { + name: 'releaseInboundUnlock'; + accounts: [ + { + name: 'common'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + accounts: [ + { + name: 'config'; + isMut: false; + isSigner: false; + }, + ]; + }, + { + name: 'inboxItem'; + isMut: true; + isSigner: false; + }, + { + name: 'recipient'; + isMut: true; + isSigner: false; + }, + { + name: 'tokenAuthority'; + isMut: false; + isSigner: false; + }, + { + name: 'mint'; + isMut: true; + isSigner: false; + }, + { + name: 'tokenProgram'; + isMut: false; + isSigner: false; + }, + ]; + }, + { + name: 'custody'; + isMut: true; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'ReleaseInboundArgs'; + }; + }, + ]; + }, + { + name: 'transferOwnership'; + accounts: [ + { + name: 'config'; + isMut: true; + isSigner: false; + }, + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'newOwner'; + isMut: false; + isSigner: false; + }, + { + name: 'upgradeLock'; + isMut: false; + isSigner: false; + }, + { + name: 'programData'; + isMut: true; + isSigner: false; + }, + { + name: 'bpfLoaderUpgradeableProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: []; + }, + { + name: 'claimOwnership'; + accounts: [ + { + name: 'config'; + isMut: true; + isSigner: false; + }, + { + name: 'upgradeLock'; + isMut: false; + isSigner: false; + }, + { + name: 'newOwner'; + isMut: false; + isSigner: true; + }, + { + name: 'programData'; + isMut: true; + isSigner: false; + }, + { + name: 'bpfLoaderUpgradeableProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: []; + }, + { + name: 'setPaused'; + accounts: [ + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'config'; + isMut: true; + isSigner: false; + }, + ]; + args: [ + { + name: 'pause'; + type: 'bool'; + }, + ]; + }, + { + name: 'setPeer'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'config'; + isMut: false; + isSigner: false; + }, + { + name: 'peer'; + isMut: true; + isSigner: false; + }, + { + name: 'inboxRateLimit'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'SetPeerArgs'; + }; + }, + ]; + }, + { + name: 'registerTransceiver'; + accounts: [ + { + name: 'config'; + isMut: true; + isSigner: false; + }, + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'transceiver'; + isMut: false; + isSigner: false; + }, + { + name: 'registeredTransceiver'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: []; + }, + { + name: 'setOutboundLimit'; + accounts: [ + { + name: 'config'; + isMut: false; + isSigner: false; + }, + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'rateLimit'; + isMut: true; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'SetOutboundLimitArgs'; + }; + }, + ]; + }, + { + name: 'setInboundLimit'; + accounts: [ + { + name: 'config'; + isMut: false; + isSigner: false; + }, + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'rateLimit'; + isMut: true; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'SetInboundLimitArgs'; + }; + }, + ]; + }, + { + name: 'setWormholePeer'; + accounts: [ + { + name: 'config'; + isMut: false; + isSigner: false; + }, + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'peer'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'SetTransceiverPeerArgs'; + }; + }, + ]; + }, + { + name: 'receiveWormholeMessage'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + isMut: false; + isSigner: false; + }, + { + name: 'peer'; + isMut: false; + isSigner: false; + }, + { + name: 'vaa'; + isMut: false; + isSigner: false; + }, + { + name: 'transceiverMessage'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: []; + }, + { + name: 'releaseWormholeOutbound'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + accounts: [ + { + name: 'config'; + isMut: false; + isSigner: false; + }, + ]; + }, + { + name: 'outboxItem'; + isMut: true; + isSigner: false; + }, + { + name: 'transceiver'; + isMut: false; + isSigner: false; + }, + { + name: 'wormholeMessage'; + isMut: true; + isSigner: false; + }, + { + name: 'emitter'; + isMut: true; + isSigner: false; + }, + { + name: 'wormhole'; + accounts: [ + { + name: 'bridge'; + isMut: true; + isSigner: false; + }, + { + name: 'feeCollector'; + isMut: true; + isSigner: false; + }, + { + name: 'sequence'; + isMut: true; + isSigner: false; + }, + { + name: 'program'; + isMut: false; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + { + name: 'clock'; + isMut: false; + isSigner: false; + }, + { + name: 'rent'; + isMut: false; + isSigner: false; + }, + ]; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'ReleaseOutboundArgs'; + }; + }, + ]; + }, + { + name: 'broadcastWormholeId'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + isMut: false; + isSigner: false; + }, + { + name: 'mint'; + isMut: false; + isSigner: false; + }, + { + name: 'wormholeMessage'; + isMut: true; + isSigner: true; + }, + { + name: 'emitter'; + isMut: true; + isSigner: false; + }, + { + name: 'wormhole'; + accounts: [ + { + name: 'bridge'; + isMut: true; + isSigner: false; + }, + { + name: 'feeCollector'; + isMut: true; + isSigner: false; + }, + { + name: 'sequence'; + isMut: true; + isSigner: false; + }, + { + name: 'program'; + isMut: false; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + { + name: 'clock'; + isMut: false; + isSigner: false; + }, + { + name: 'rent'; + isMut: false; + isSigner: false; + }, + ]; + }, + ]; + args: []; + }, + { + name: 'broadcastWormholePeer'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'config'; + isMut: false; + isSigner: false; + }, + { + name: 'peer'; + isMut: false; + isSigner: false; + }, + { + name: 'wormholeMessage'; + isMut: true; + isSigner: true; + }, + { + name: 'emitter'; + isMut: true; + isSigner: false; + }, + { + name: 'wormhole'; + accounts: [ + { + name: 'bridge'; + isMut: true; + isSigner: false; + }, + { + name: 'feeCollector'; + isMut: true; + isSigner: false; + }, + { + name: 'sequence'; + isMut: true; + isSigner: false; + }, + { + name: 'program'; + isMut: false; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + { + name: 'clock'; + isMut: false; + isSigner: false; + }, + { + name: 'rent'; + isMut: false; + isSigner: false; + }, + ]; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'BroadcastPeerArgs'; + }; + }, + ]; + }, + ]; + accounts: [ + { + name: 'config'; + type: { + kind: 'struct'; + fields: [ + { + name: 'bump'; + type: 'u8'; + }, + { + name: 'owner'; + docs: ['Owner of the program.']; + type: 'publicKey'; + }, + { + name: 'pendingOwner'; + docs: ['Pending next owner (before claiming ownership).']; + type: { + option: 'publicKey'; + }; + }, + { + name: 'mint'; + docs: ['Mint address of the token managed by this program.']; + type: 'publicKey'; + }, + { + name: 'tokenProgram'; + docs: [ + 'Address of the token program (token or token22). This could always be queried', + "from the [`mint`] account's owner, but storing it here avoids an indirection", + 'on the client side.', + ]; + type: 'publicKey'; + }, + { + name: 'mode'; + docs: [ + 'The mode that this program is running in. This is used to determine', + 'whether the program is burning tokens or locking tokens.', + ]; + type: { + defined: 'Mode'; + }; + }, + { + name: 'chainId'; + docs: [ + "The chain id of the chain that this program is running on. We don't", + 'hardcode this so that the program is deployable on any potential SVM', + 'forks.', + ]; + type: { + defined: 'ChainId'; + }; + }, + { + name: 'nextTransceiverId'; + docs: [ + 'The next transceiver id to use when registering an transceiver.', + ]; + type: 'u8'; + }, + { + name: 'threshold'; + docs: [ + 'The number of transceivers that must attest to a transfer before it is', + 'accepted.', + ]; + type: 'u8'; + }, + { + name: 'enabledTransceivers'; + docs: ['Bitmap of enabled transceivers']; + type: { + defined: 'Bitmap'; + }; + }, + { + name: 'paused'; + docs: [ + 'Pause the program. This is useful for upgrades and other maintenance.', + ]; + type: 'bool'; + }, + { + name: 'custody'; + docs: ['The custody account that holds tokens in locking mode.']; + type: 'publicKey'; + }, + ]; + }; + }, + { + name: 'nttManagerPeer'; + docs: [ + 'A peer on another chain. Stored in a PDA seeded by the chain id.', + ]; + type: { + kind: 'struct'; + fields: [ + { + name: 'bump'; + type: 'u8'; + }, + { + name: 'address'; + type: { + array: ['u8', 32]; + }; + }, + { + name: 'tokenDecimals'; + type: 'u8'; + }, + ]; + }; + }, + { + name: 'inboxItem'; + type: { + kind: 'struct'; + fields: [ + { + name: 'init'; + type: 'bool'; + }, + { + name: 'bump'; + type: 'u8'; + }, + { + name: 'amount'; + type: 'u64'; + }, + { + name: 'recipientAddress'; + type: 'publicKey'; + }, + { + name: 'votes'; + type: { + defined: 'Bitmap'; + }; + }, + { + name: 'releaseStatus'; + type: { + defined: 'ReleaseStatus'; + }; + }, + ]; + }; + }, + { + name: 'inboxRateLimit'; + docs: [ + 'Inbound rate limit per chain.', + 'SECURITY: must check the PDA (since there are multiple PDAs, namely one for each chain.)', + ]; + type: { + kind: 'struct'; + fields: [ + { + name: 'bump'; + type: 'u8'; + }, + { + name: 'rateLimit'; + type: { + defined: 'RateLimitState'; + }; + }, + ]; + }; + }, + { + name: 'outboxItem'; + type: { + kind: 'struct'; + fields: [ + { + name: 'amount'; + type: { + defined: 'TrimmedAmount'; + }; + }, + { + name: 'sender'; + type: 'publicKey'; + }, + { + name: 'recipientChain'; + type: { + defined: 'ChainId'; + }; + }, + { + name: 'recipientNttManager'; + type: { + array: ['u8', 32]; + }; + }, + { + name: 'recipientAddress'; + type: { + array: ['u8', 32]; + }; + }, + { + name: 'releaseTimestamp'; + type: 'i64'; + }, + { + name: 'released'; + type: { + defined: 'Bitmap'; + }; + }, + ]; + }; + }, + { + name: 'outboxRateLimit'; + type: { + kind: 'struct'; + fields: [ + { + name: 'rateLimit'; + type: { + defined: 'RateLimitState'; + }; + }, + ]; + }; + }, + { + name: 'registeredTransceiver'; + type: { + kind: 'struct'; + fields: [ + { + name: 'bump'; + type: 'u8'; + }, + { + name: 'id'; + type: 'u8'; + }, + { + name: 'transceiverAddress'; + type: 'publicKey'; + }, + ]; + }; + }, + { + name: 'transceiverPeer'; + docs: [ + 'A peer on another chain. Stored in a PDA seeded by the chain id.', + ]; + type: { + kind: 'struct'; + fields: [ + { + name: 'bump'; + type: 'u8'; + }, + { + name: 'address'; + type: { + array: ['u8', 32]; + }; + }, + ]; + }; + }, + { + name: 'bridgeData'; + type: { + kind: 'struct'; + fields: [ + { + name: 'guardianSetIndex'; + docs: [ + 'The current guardian set index, used to decide which signature sets to accept.', + ]; + type: 'u32'; + }, + { + name: 'lastLamports'; + docs: ['Lamports in the collection account']; + type: 'u64'; + }, + { + name: 'config'; + docs: [ + 'Bridge configuration, which is set once upon initialization.', + ]; + type: { + defined: 'BridgeConfig'; + }; + }, + ]; + }; + }, + ]; + types: [ + { + name: 'Bitmap'; + type: { + kind: 'struct'; + fields: [ + { + name: 'map'; + type: 'u128'; + }, + ]; + }; + }, + { + name: 'SetInboundLimitArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'limit'; + type: 'u64'; + }, + { + name: 'chainId'; + type: { + defined: 'ChainId'; + }; + }, + ]; + }; + }, + { + name: 'SetOutboundLimitArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'limit'; + type: 'u64'; + }, + ]; + }; + }, + { + name: 'SetPeerArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'chainId'; + type: { + defined: 'ChainId'; + }; + }, + { + name: 'address'; + type: { + array: ['u8', 32]; + }; + }, + { + name: 'limit'; + type: 'u64'; + }, + { + name: 'tokenDecimals'; + docs: ['The token decimals on the peer chain.']; + type: 'u8'; + }, + ]; + }; + }, + { + name: 'InitializeArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'chainId'; + type: 'u16'; + }, + { + name: 'limit'; + type: 'u64'; + }, + { + name: 'mode'; + type: { + defined: 'Mode'; + }; + }, + ]; + }; + }, + { + name: 'RedeemArgs'; + type: { + kind: 'struct'; + fields: []; + }; + }, + { + name: 'ReleaseInboundArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'revertOnDelay'; + type: 'bool'; + }, + ]; + }; + }, + { + name: 'TransferArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'amount'; + type: 'u64'; + }, + { + name: 'recipientChain'; + type: { + defined: 'ChainId'; + }; + }, + { + name: 'recipientAddress'; + type: { + array: ['u8', 32]; + }; + }, + { + name: 'shouldQueue'; + type: 'bool'; + }, + ]; + }; + }, + { + name: 'ReleaseStatus'; + type: { + kind: 'enum'; + variants: [ + { + name: 'NotApproved'; + }, + { + name: 'ReleaseAfter'; + fields: ['i64']; + }, + { + name: 'Released'; + }, + ]; + }; + }, + { + name: 'RateLimitState'; + type: { + kind: 'struct'; + fields: [ + { + name: 'limit'; + docs: ['The maximum capacity of the rate limiter.']; + type: 'u64'; + }, + { + name: 'capacityAtLastTx'; + docs: [ + 'The capacity of the rate limiter at `last_tx_timestamp`.', + 'The actual current capacity is calculated in `capacity_at`, by', + 'accounting for the time that has passed since `last_tx_timestamp` and', + 'the refill rate.', + ]; + type: 'u64'; + }, + { + name: 'lastTxTimestamp'; + docs: [ + 'The timestamp of the last transaction that counted towards the current', + 'capacity. Transactions that exceeded the capacity do not count, they are', + 'just delayed.', + ]; + type: 'i64'; + }, + ]; + }; + }, + { + name: 'SetTransceiverPeerArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'chainId'; + type: { + defined: 'ChainId'; + }; + }, + { + name: 'address'; + type: { + array: ['u8', 32]; + }; + }, + ]; + }; + }, + { + name: 'BroadcastPeerArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'chainId'; + type: 'u16'; + }, + ]; + }; + }, + { + name: 'ReleaseOutboundArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'revertOnDelay'; + type: 'bool'; + }, + ]; + }; + }, + { + name: 'ChainId'; + type: { + kind: 'struct'; + fields: [ + { + name: 'id'; + type: 'u16'; + }, + ]; + }; + }, + { + name: 'Mode'; + type: { + kind: 'enum'; + variants: [ + { + name: 'Locking'; + }, + { + name: 'Burning'; + }, + ]; + }; + }, + { + name: 'TrimmedAmount'; + type: { + kind: 'struct'; + fields: [ + { + name: 'amount'; + type: 'u64'; + }, + { + name: 'decimals'; + type: 'u8'; + }, + ]; + }; + }, + { + name: 'BridgeConfig'; + type: { + kind: 'struct'; + fields: [ + { + name: 'guardianSetExpirationTime'; + docs: [ + 'Period for how long a guardian set is valid after it has been replaced by a new one. This', + 'guarantees that VAAs issued by that set can still be submitted for a certain period. In', + 'this period we still trust the old guardian set.', + ]; + type: 'u32'; + }, + { + name: 'fee'; + docs: [ + 'Amount of lamports that needs to be paid to the protocol to post a message', + ]; + type: 'u64'; + }, + ]; + }; + }, + ]; + errors: [ + { + code: 6000; + name: 'CantReleaseYet'; + msg: 'CantReleaseYet'; + }, + { + code: 6001; + name: 'InvalidPendingOwner'; + msg: 'InvalidPendingOwner'; + }, + { + code: 6002; + name: 'InvalidChainId'; + msg: 'InvalidChainId'; + }, + { + code: 6003; + name: 'InvalidRecipientAddress'; + msg: 'InvalidRecipientAddress'; + }, + { + code: 6004; + name: 'InvalidTransceiverPeer'; + msg: 'InvalidTransceiverPeer'; + }, + { + code: 6005; + name: 'InvalidNttManagerPeer'; + msg: 'InvalidNttManagerPeer'; + }, + { + code: 6006; + name: 'InvalidRecipientNttManager'; + msg: 'InvalidRecipientNttManager'; + }, + { + code: 6007; + name: 'TransferAlreadyRedeemed'; + msg: 'TransferAlreadyRedeemed'; + }, + { + code: 6008; + name: 'TransferCannotBeRedeemed'; + msg: 'TransferCannotBeRedeemed'; + }, + { + code: 6009; + name: 'TransferNotApproved'; + msg: 'TransferNotApproved'; + }, + { + code: 6010; + name: 'MessageAlreadySent'; + msg: 'MessageAlreadySent'; + }, + { + code: 6011; + name: 'InvalidMode'; + msg: 'InvalidMode'; + }, + { + code: 6012; + name: 'InvalidMintAuthority'; + msg: 'InvalidMintAuthority'; + }, + { + code: 6013; + name: 'TransferExceedsRateLimit'; + msg: 'TransferExceedsRateLimit'; + }, + { + code: 6014; + name: 'Paused'; + msg: 'Paused'; + }, + { + code: 6015; + name: 'DisabledTransceiver'; + msg: 'DisabledTransceiver'; + }, + { + code: 6016; + name: 'InvalidDeployer'; + msg: 'InvalidDeployer'; + }, + ]; +}; + +export const IDL: ExampleNativeTokenTransfers = { + version: '0.1.0', + name: 'example_native_token_transfers', + instructions: [ + { + name: 'initialize', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'deployer', + isMut: false, + isSigner: true, + }, + { + name: 'programData', + isMut: false, + isSigner: false, + }, + { + name: 'config', + isMut: true, + isSigner: false, + }, + { + name: 'mint', + isMut: false, + isSigner: false, + }, + { + name: 'rateLimit', + isMut: true, + isSigner: false, + }, + { + name: 'tokenAuthority', + isMut: false, + isSigner: false, + }, + { + name: 'custody', + isMut: true, + isSigner: false, + docs: [ + 'The custody account that holds tokens in locking mode.', + 'NOTE: the account is unconditionally initialized, but not used in', + 'burning mode.', + ], + }, + { + name: 'tokenProgram', + isMut: false, + isSigner: false, + docs: ['associated token account for the given mint.'], + }, + { + name: 'associatedTokenProgram', + isMut: false, + isSigner: false, + }, + { + name: 'bpfLoaderUpgradeableProgram', + isMut: false, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'InitializeArgs', + }, + }, + ], + }, + { + name: 'transferBurn', + accounts: [ + { + name: 'common', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + accounts: [ + { + name: 'config', + isMut: false, + isSigner: false, + }, + ], + }, + { + name: 'mint', + isMut: true, + isSigner: false, + }, + { + name: 'from', + isMut: true, + isSigner: false, + docs: ['account can spend these tokens.'], + }, + { + name: 'tokenProgram', + isMut: false, + isSigner: false, + }, + { + name: 'outboxItem', + isMut: true, + isSigner: true, + }, + { + name: 'outboxRateLimit', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + }, + { + name: 'inboxRateLimit', + isMut: true, + isSigner: false, + }, + { + name: 'peer', + isMut: false, + isSigner: false, + }, + { + name: 'sessionAuthority', + isMut: false, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'TransferArgs', + }, + }, + ], + }, + { + name: 'transferLock', + accounts: [ + { + name: 'common', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + accounts: [ + { + name: 'config', + isMut: false, + isSigner: false, + }, + ], + }, + { + name: 'mint', + isMut: true, + isSigner: false, + }, + { + name: 'from', + isMut: true, + isSigner: false, + docs: ['account can spend these tokens.'], + }, + { + name: 'tokenProgram', + isMut: false, + isSigner: false, + }, + { + name: 'outboxItem', + isMut: true, + isSigner: true, + }, + { + name: 'outboxRateLimit', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + }, + { + name: 'inboxRateLimit', + isMut: true, + isSigner: false, + }, + { + name: 'peer', + isMut: false, + isSigner: false, + }, + { + name: 'sessionAuthority', + isMut: false, + isSigner: false, + }, + { + name: 'custody', + isMut: true, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'TransferArgs', + }, + }, + ], + }, + { + name: 'redeem', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + isMut: false, + isSigner: false, + }, + { + name: 'peer', + isMut: false, + isSigner: false, + }, + { + name: 'transceiverMessage', + isMut: false, + isSigner: false, + }, + { + name: 'transceiver', + isMut: false, + isSigner: false, + }, + { + name: 'mint', + isMut: false, + isSigner: false, + }, + { + name: 'inboxItem', + isMut: true, + isSigner: false, + docs: [ + 'NOTE: This account is content-addressed (PDA seeded by the message hash).', + 'This is because in a multi-transceiver configuration, the different', + 'transceivers "vote" on messages (by delivering them). By making the inbox', + "items content-addressed, we can ensure that disagreeing votes don't", + 'interfere with each other.', + ], + }, + { + name: 'inboxRateLimit', + isMut: true, + isSigner: false, + }, + { + name: 'outboxRateLimit', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'RedeemArgs', + }, + }, + ], + }, + { + name: 'releaseInboundMint', + accounts: [ + { + name: 'common', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + accounts: [ + { + name: 'config', + isMut: false, + isSigner: false, + }, + ], + }, + { + name: 'inboxItem', + isMut: true, + isSigner: false, + }, + { + name: 'recipient', + isMut: true, + isSigner: false, + }, + { + name: 'tokenAuthority', + isMut: false, + isSigner: false, + }, + { + name: 'mint', + isMut: true, + isSigner: false, + }, + { + name: 'tokenProgram', + isMut: false, + isSigner: false, + }, + ], + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'ReleaseInboundArgs', + }, + }, + ], + }, + { + name: 'releaseInboundUnlock', + accounts: [ + { + name: 'common', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + accounts: [ + { + name: 'config', + isMut: false, + isSigner: false, + }, + ], + }, + { + name: 'inboxItem', + isMut: true, + isSigner: false, + }, + { + name: 'recipient', + isMut: true, + isSigner: false, + }, + { + name: 'tokenAuthority', + isMut: false, + isSigner: false, + }, + { + name: 'mint', + isMut: true, + isSigner: false, + }, + { + name: 'tokenProgram', + isMut: false, + isSigner: false, + }, + ], + }, + { + name: 'custody', + isMut: true, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'ReleaseInboundArgs', + }, + }, + ], + }, + { + name: 'transferOwnership', + accounts: [ + { + name: 'config', + isMut: true, + isSigner: false, + }, + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'newOwner', + isMut: false, + isSigner: false, + }, + { + name: 'upgradeLock', + isMut: false, + isSigner: false, + }, + { + name: 'programData', + isMut: true, + isSigner: false, + }, + { + name: 'bpfLoaderUpgradeableProgram', + isMut: false, + isSigner: false, + }, + ], + args: [], + }, + { + name: 'claimOwnership', + accounts: [ + { + name: 'config', + isMut: true, + isSigner: false, + }, + { + name: 'upgradeLock', + isMut: false, + isSigner: false, + }, + { + name: 'newOwner', + isMut: false, + isSigner: true, + }, + { + name: 'programData', + isMut: true, + isSigner: false, + }, + { + name: 'bpfLoaderUpgradeableProgram', + isMut: false, + isSigner: false, + }, + ], + args: [], + }, + { + name: 'setPaused', + accounts: [ + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'config', + isMut: true, + isSigner: false, + }, + ], + args: [ + { + name: 'pause', + type: 'bool', + }, + ], + }, + { + name: 'setPeer', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'config', + isMut: false, + isSigner: false, + }, + { + name: 'peer', + isMut: true, + isSigner: false, + }, + { + name: 'inboxRateLimit', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'SetPeerArgs', + }, + }, + ], + }, + { + name: 'registerTransceiver', + accounts: [ + { + name: 'config', + isMut: true, + isSigner: false, + }, + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'transceiver', + isMut: false, + isSigner: false, + }, + { + name: 'registeredTransceiver', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [], + }, + { + name: 'setOutboundLimit', + accounts: [ + { + name: 'config', + isMut: false, + isSigner: false, + }, + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'rateLimit', + isMut: true, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'SetOutboundLimitArgs', + }, + }, + ], + }, + { + name: 'setInboundLimit', + accounts: [ + { + name: 'config', + isMut: false, + isSigner: false, + }, + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'rateLimit', + isMut: true, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'SetInboundLimitArgs', + }, + }, + ], + }, + { + name: 'setWormholePeer', + accounts: [ + { + name: 'config', + isMut: false, + isSigner: false, + }, + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'peer', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'SetTransceiverPeerArgs', + }, + }, + ], + }, + { + name: 'receiveWormholeMessage', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + isMut: false, + isSigner: false, + }, + { + name: 'peer', + isMut: false, + isSigner: false, + }, + { + name: 'vaa', + isMut: false, + isSigner: false, + }, + { + name: 'transceiverMessage', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [], + }, + { + name: 'releaseWormholeOutbound', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + accounts: [ + { + name: 'config', + isMut: false, + isSigner: false, + }, + ], + }, + { + name: 'outboxItem', + isMut: true, + isSigner: false, + }, + { + name: 'transceiver', + isMut: false, + isSigner: false, + }, + { + name: 'wormholeMessage', + isMut: true, + isSigner: false, + }, + { + name: 'emitter', + isMut: true, + isSigner: false, + }, + { + name: 'wormhole', + accounts: [ + { + name: 'bridge', + isMut: true, + isSigner: false, + }, + { + name: 'feeCollector', + isMut: true, + isSigner: false, + }, + { + name: 'sequence', + isMut: true, + isSigner: false, + }, + { + name: 'program', + isMut: false, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + { + name: 'clock', + isMut: false, + isSigner: false, + }, + { + name: 'rent', + isMut: false, + isSigner: false, + }, + ], + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'ReleaseOutboundArgs', + }, + }, + ], + }, + { + name: 'broadcastWormholeId', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + isMut: false, + isSigner: false, + }, + { + name: 'mint', + isMut: false, + isSigner: false, + }, + { + name: 'wormholeMessage', + isMut: true, + isSigner: true, + }, + { + name: 'emitter', + isMut: true, + isSigner: false, + }, + { + name: 'wormhole', + accounts: [ + { + name: 'bridge', + isMut: true, + isSigner: false, + }, + { + name: 'feeCollector', + isMut: true, + isSigner: false, + }, + { + name: 'sequence', + isMut: true, + isSigner: false, + }, + { + name: 'program', + isMut: false, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + { + name: 'clock', + isMut: false, + isSigner: false, + }, + { + name: 'rent', + isMut: false, + isSigner: false, + }, + ], + }, + ], + args: [], + }, + { + name: 'broadcastWormholePeer', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'config', + isMut: false, + isSigner: false, + }, + { + name: 'peer', + isMut: false, + isSigner: false, + }, + { + name: 'wormholeMessage', + isMut: true, + isSigner: true, + }, + { + name: 'emitter', + isMut: true, + isSigner: false, + }, + { + name: 'wormhole', + accounts: [ + { + name: 'bridge', + isMut: true, + isSigner: false, + }, + { + name: 'feeCollector', + isMut: true, + isSigner: false, + }, + { + name: 'sequence', + isMut: true, + isSigner: false, + }, + { + name: 'program', + isMut: false, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + { + name: 'clock', + isMut: false, + isSigner: false, + }, + { + name: 'rent', + isMut: false, + isSigner: false, + }, + ], + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'BroadcastPeerArgs', + }, + }, + ], + }, + ], + accounts: [ + { + name: 'config', + type: { + kind: 'struct', + fields: [ + { + name: 'bump', + type: 'u8', + }, + { + name: 'owner', + docs: ['Owner of the program.'], + type: 'publicKey', + }, + { + name: 'pendingOwner', + docs: ['Pending next owner (before claiming ownership).'], + type: { + option: 'publicKey', + }, + }, + { + name: 'mint', + docs: ['Mint address of the token managed by this program.'], + type: 'publicKey', + }, + { + name: 'tokenProgram', + docs: [ + 'Address of the token program (token or token22). This could always be queried', + "from the [`mint`] account's owner, but storing it here avoids an indirection", + 'on the client side.', + ], + type: 'publicKey', + }, + { + name: 'mode', + docs: [ + 'The mode that this program is running in. This is used to determine', + 'whether the program is burning tokens or locking tokens.', + ], + type: { + defined: 'Mode', + }, + }, + { + name: 'chainId', + docs: [ + "The chain id of the chain that this program is running on. We don't", + 'hardcode this so that the program is deployable on any potential SVM', + 'forks.', + ], + type: { + defined: 'ChainId', + }, + }, + { + name: 'nextTransceiverId', + docs: [ + 'The next transceiver id to use when registering an transceiver.', + ], + type: 'u8', + }, + { + name: 'threshold', + docs: [ + 'The number of transceivers that must attest to a transfer before it is', + 'accepted.', + ], + type: 'u8', + }, + { + name: 'enabledTransceivers', + docs: ['Bitmap of enabled transceivers'], + type: { + defined: 'Bitmap', + }, + }, + { + name: 'paused', + docs: [ + 'Pause the program. This is useful for upgrades and other maintenance.', + ], + type: 'bool', + }, + { + name: 'custody', + docs: ['The custody account that holds tokens in locking mode.'], + type: 'publicKey', + }, + ], + }, + }, + { + name: 'nttManagerPeer', + docs: [ + 'A peer on another chain. Stored in a PDA seeded by the chain id.', + ], + type: { + kind: 'struct', + fields: [ + { + name: 'bump', + type: 'u8', + }, + { + name: 'address', + type: { + array: ['u8', 32], + }, + }, + { + name: 'tokenDecimals', + type: 'u8', + }, + ], + }, + }, + { + name: 'inboxItem', + type: { + kind: 'struct', + fields: [ + { + name: 'init', + type: 'bool', + }, + { + name: 'bump', + type: 'u8', + }, + { + name: 'amount', + type: 'u64', + }, + { + name: 'recipientAddress', + type: 'publicKey', + }, + { + name: 'votes', + type: { + defined: 'Bitmap', + }, + }, + { + name: 'releaseStatus', + type: { + defined: 'ReleaseStatus', + }, + }, + ], + }, + }, + { + name: 'inboxRateLimit', + docs: [ + 'Inbound rate limit per chain.', + 'SECURITY: must check the PDA (since there are multiple PDAs, namely one for each chain.)', + ], + type: { + kind: 'struct', + fields: [ + { + name: 'bump', + type: 'u8', + }, + { + name: 'rateLimit', + type: { + defined: 'RateLimitState', + }, + }, + ], + }, + }, + { + name: 'outboxItem', + type: { + kind: 'struct', + fields: [ + { + name: 'amount', + type: { + defined: 'TrimmedAmount', + }, + }, + { + name: 'sender', + type: 'publicKey', + }, + { + name: 'recipientChain', + type: { + defined: 'ChainId', + }, + }, + { + name: 'recipientNttManager', + type: { + array: ['u8', 32], + }, + }, + { + name: 'recipientAddress', + type: { + array: ['u8', 32], + }, + }, + { + name: 'releaseTimestamp', + type: 'i64', + }, + { + name: 'released', + type: { + defined: 'Bitmap', + }, + }, + ], + }, + }, + { + name: 'outboxRateLimit', + type: { + kind: 'struct', + fields: [ + { + name: 'rateLimit', + type: { + defined: 'RateLimitState', + }, + }, + ], + }, + }, + { + name: 'registeredTransceiver', + type: { + kind: 'struct', + fields: [ + { + name: 'bump', + type: 'u8', + }, + { + name: 'id', + type: 'u8', + }, + { + name: 'transceiverAddress', + type: 'publicKey', + }, + ], + }, + }, + { + name: 'transceiverPeer', + docs: [ + 'A peer on another chain. Stored in a PDA seeded by the chain id.', + ], + type: { + kind: 'struct', + fields: [ + { + name: 'bump', + type: 'u8', + }, + { + name: 'address', + type: { + array: ['u8', 32], + }, + }, + ], + }, + }, + { + name: 'bridgeData', + type: { + kind: 'struct', + fields: [ + { + name: 'guardianSetIndex', + docs: [ + 'The current guardian set index, used to decide which signature sets to accept.', + ], + type: 'u32', + }, + { + name: 'lastLamports', + docs: ['Lamports in the collection account'], + type: 'u64', + }, + { + name: 'config', + docs: [ + 'Bridge configuration, which is set once upon initialization.', + ], + type: { + defined: 'BridgeConfig', + }, + }, + ], + }, + }, + ], + types: [ + { + name: 'Bitmap', + type: { + kind: 'struct', + fields: [ + { + name: 'map', + type: 'u128', + }, + ], + }, + }, + { + name: 'SetInboundLimitArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'limit', + type: 'u64', + }, + { + name: 'chainId', + type: { + defined: 'ChainId', + }, + }, + ], + }, + }, + { + name: 'SetOutboundLimitArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'limit', + type: 'u64', + }, + ], + }, + }, + { + name: 'SetPeerArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'chainId', + type: { + defined: 'ChainId', + }, + }, + { + name: 'address', + type: { + array: ['u8', 32], + }, + }, + { + name: 'limit', + type: 'u64', + }, + { + name: 'tokenDecimals', + docs: ['The token decimals on the peer chain.'], + type: 'u8', + }, + ], + }, + }, + { + name: 'InitializeArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'chainId', + type: 'u16', + }, + { + name: 'limit', + type: 'u64', + }, + { + name: 'mode', + type: { + defined: 'Mode', + }, + }, + ], + }, + }, + { + name: 'RedeemArgs', + type: { + kind: 'struct', + fields: [], + }, + }, + { + name: 'ReleaseInboundArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'revertOnDelay', + type: 'bool', + }, + ], + }, + }, + { + name: 'TransferArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'amount', + type: 'u64', + }, + { + name: 'recipientChain', + type: { + defined: 'ChainId', + }, + }, + { + name: 'recipientAddress', + type: { + array: ['u8', 32], + }, + }, + { + name: 'shouldQueue', + type: 'bool', + }, + ], + }, + }, + { + name: 'ReleaseStatus', + type: { + kind: 'enum', + variants: [ + { + name: 'NotApproved', + }, + { + name: 'ReleaseAfter', + fields: ['i64'], + }, + { + name: 'Released', + }, + ], + }, + }, + { + name: 'RateLimitState', + type: { + kind: 'struct', + fields: [ + { + name: 'limit', + docs: ['The maximum capacity of the rate limiter.'], + type: 'u64', + }, + { + name: 'capacityAtLastTx', + docs: [ + 'The capacity of the rate limiter at `last_tx_timestamp`.', + 'The actual current capacity is calculated in `capacity_at`, by', + 'accounting for the time that has passed since `last_tx_timestamp` and', + 'the refill rate.', + ], + type: 'u64', + }, + { + name: 'lastTxTimestamp', + docs: [ + 'The timestamp of the last transaction that counted towards the current', + 'capacity. Transactions that exceeded the capacity do not count, they are', + 'just delayed.', + ], + type: 'i64', + }, + ], + }, + }, + { + name: 'SetTransceiverPeerArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'chainId', + type: { + defined: 'ChainId', + }, + }, + { + name: 'address', + type: { + array: ['u8', 32], + }, + }, + ], + }, + }, + { + name: 'BroadcastPeerArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'chainId', + type: 'u16', + }, + ], + }, + }, + { + name: 'ReleaseOutboundArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'revertOnDelay', + type: 'bool', + }, + ], + }, + }, + { + name: 'ChainId', + type: { + kind: 'struct', + fields: [ + { + name: 'id', + type: 'u16', + }, + ], + }, + }, + { + name: 'Mode', + type: { + kind: 'enum', + variants: [ + { + name: 'Locking', + }, + { + name: 'Burning', + }, + ], + }, + }, + { + name: 'TrimmedAmount', + type: { + kind: 'struct', + fields: [ + { + name: 'amount', + type: 'u64', + }, + { + name: 'decimals', + type: 'u8', + }, + ], + }, + }, + { + name: 'BridgeConfig', + type: { + kind: 'struct', + fields: [ + { + name: 'guardianSetExpirationTime', + docs: [ + 'Period for how long a guardian set is valid after it has been replaced by a new one. This', + 'guarantees that VAAs issued by that set can still be submitted for a certain period. In', + 'this period we still trust the old guardian set.', + ], + type: 'u32', + }, + { + name: 'fee', + docs: [ + 'Amount of lamports that needs to be paid to the protocol to post a message', + ], + type: 'u64', + }, + ], + }, + }, + ], + errors: [ + { + code: 6000, + name: 'CantReleaseYet', + msg: 'CantReleaseYet', + }, + { + code: 6001, + name: 'InvalidPendingOwner', + msg: 'InvalidPendingOwner', + }, + { + code: 6002, + name: 'InvalidChainId', + msg: 'InvalidChainId', + }, + { + code: 6003, + name: 'InvalidRecipientAddress', + msg: 'InvalidRecipientAddress', + }, + { + code: 6004, + name: 'InvalidTransceiverPeer', + msg: 'InvalidTransceiverPeer', + }, + { + code: 6005, + name: 'InvalidNttManagerPeer', + msg: 'InvalidNttManagerPeer', + }, + { + code: 6006, + name: 'InvalidRecipientNttManager', + msg: 'InvalidRecipientNttManager', + }, + { + code: 6007, + name: 'TransferAlreadyRedeemed', + msg: 'TransferAlreadyRedeemed', + }, + { + code: 6008, + name: 'TransferCannotBeRedeemed', + msg: 'TransferCannotBeRedeemed', + }, + { + code: 6009, + name: 'TransferNotApproved', + msg: 'TransferNotApproved', + }, + { + code: 6010, + name: 'MessageAlreadySent', + msg: 'MessageAlreadySent', + }, + { + code: 6011, + name: 'InvalidMode', + msg: 'InvalidMode', + }, + { + code: 6012, + name: 'InvalidMintAuthority', + msg: 'InvalidMintAuthority', + }, + { + code: 6013, + name: 'TransferExceedsRateLimit', + msg: 'TransferExceedsRateLimit', + }, + { + code: 6014, + name: 'Paused', + msg: 'Paused', + }, + { + code: 6015, + name: 'DisabledTransceiver', + msg: 'DisabledTransceiver', + }, + { + code: 6016, + name: 'InvalidDeployer', + msg: 'InvalidDeployer', + }, + ], +}; diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/types/ntt_quoter.ts b/wormhole-connect/src/routes/ntt/platforms/solana/types/ntt_quoter.ts new file mode 100644 index 000000000..2a9c6393e --- /dev/null +++ b/wormhole-connect/src/routes/ntt/platforms/solana/types/ntt_quoter.ts @@ -0,0 +1,885 @@ +export type NttQuoter = { + version: '0.1.0'; + name: 'ntt_quoter'; + instructions: [ + { + name: 'requestRelay'; + accounts: [ + { + name: 'payer'; + isMut: true; + isSigner: true; + }, + { + name: 'instance'; + isMut: false; + isSigner: false; + }, + { + name: 'registeredChain'; + isMut: false; + isSigner: false; + }, + { + name: 'outboxItem'; + isMut: false; + isSigner: false; + }, + { + name: 'relayRequest'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'RequestRelayArgs'; + }; + }, + ]; + }, + { + name: 'closeRelay'; + accounts: [ + { + name: 'authority'; + isMut: false; + isSigner: true; + }, + { + name: 'instance'; + isMut: false; + isSigner: false; + }, + { + name: 'feeRecipient'; + isMut: true; + isSigner: false; + }, + { + name: 'relayRequest'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: []; + }, + { + name: 'initialize'; + accounts: [ + { + name: 'owner'; + isMut: true; + isSigner: true; + }, + { + name: 'instance'; + isMut: true; + isSigner: false; + }, + { + name: 'feeRecipient'; + isMut: false; + isSigner: false; + }, + { + name: 'programData'; + isMut: true; + isSigner: false; + docs: [ + 'We use the program data to make sure this owner is the upgrade authority (the true owner,', + 'who deployed this program).', + ]; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: []; + }, + { + name: 'setAssistant'; + accounts: [ + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'instance'; + isMut: true; + isSigner: false; + }, + { + name: 'assistant'; + isMut: false; + isSigner: false; + isOptional: true; + }, + ]; + args: []; + }, + { + name: 'setFeeRecipient'; + accounts: [ + { + name: 'owner'; + isMut: false; + isSigner: true; + }, + { + name: 'instance'; + isMut: true; + isSigner: false; + }, + { + name: 'feeRecipient'; + isMut: false; + isSigner: false; + }, + ]; + args: []; + }, + { + name: 'registerChain'; + accounts: [ + { + name: 'authority'; + isMut: true; + isSigner: true; + }, + { + name: 'instance'; + isMut: false; + isSigner: false; + }, + { + name: 'registeredChain'; + isMut: true; + isSigner: false; + }, + { + name: 'systemProgram'; + isMut: false; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'RegisterChainArgs'; + }; + }, + ]; + }, + { + name: 'updateSolPrice'; + accounts: [ + { + name: 'authority'; + isMut: false; + isSigner: true; + }, + { + name: 'instance'; + isMut: false; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'UpdateSolPriceArgs'; + }; + }, + ]; + }, + { + name: 'updateChainPrices'; + accounts: [ + { + name: 'authority'; + isMut: false; + isSigner: true; + }, + { + name: 'instance'; + isMut: false; + isSigner: false; + }, + { + name: 'registeredChain'; + isMut: true; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'UpdateChainPricesArgs'; + }; + }, + ]; + }, + { + name: 'updateChainParams'; + accounts: [ + { + name: 'authority'; + isMut: false; + isSigner: true; + }, + { + name: 'instance'; + isMut: false; + isSigner: false; + }, + { + name: 'registeredChain'; + isMut: true; + isSigner: false; + }, + ]; + args: [ + { + name: 'args'; + type: { + defined: 'UpdateChainParamsArgs'; + }; + }, + ]; + }, + ]; + accounts: [ + { + name: 'instance'; + type: { + kind: 'struct'; + fields: [ + { + name: 'owner'; + type: 'publicKey'; + }, + { + name: 'assistant'; + type: 'publicKey'; + }, + { + name: 'feeRecipient'; + type: 'publicKey'; + }, + { + name: 'solPrice'; + type: 'u64'; + }, + ]; + }; + }, + { + name: 'registeredChain'; + type: { + kind: 'struct'; + fields: [ + { + name: 'bump'; + type: 'u8'; + }, + { + name: 'maxGasDropoff'; + type: 'u64'; + }, + { + name: 'basePrice'; + type: 'u64'; + }, + { + name: 'nativePrice'; + type: 'u64'; + }, + { + name: 'gasPrice'; + type: 'u64'; + }, + ]; + }; + }, + { + name: 'relayRequest'; + type: { + kind: 'struct'; + fields: [ + { + name: 'requestedGasDropoff'; + type: 'u64'; + }, + ]; + }; + }, + ]; + types: [ + { + name: 'RegisterChainArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'chainId'; + type: 'u16'; + }, + ]; + }; + }, + { + name: 'RequestRelayArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'gasDropoff'; + type: 'u64'; + }, + { + name: 'maxFee'; + type: 'u64'; + }, + ]; + }; + }, + { + name: 'UpdateSolPriceArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'solPrice'; + type: 'u64'; + }, + ]; + }; + }, + { + name: 'UpdateChainPricesArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'nativePrice'; + type: 'u64'; + }, + { + name: 'gasPrice'; + type: 'u64'; + }, + ]; + }; + }, + { + name: 'UpdateChainParamsArgs'; + type: { + kind: 'struct'; + fields: [ + { + name: 'maxGasDropoff'; + type: 'u64'; + }, + { + name: 'basePrice'; + type: 'u64'; + }, + ]; + }; + }, + ]; + errors: [ + { + code: 6001; + name: 'ExceedsUserMaxFee'; + msg: 'Relay fees exceeds specified max'; + }, + { + code: 6002; + name: 'ExceedsMaxGasDropoff'; + msg: 'Requested gas dropoff exceeds max allowed for chain'; + }, + { + code: 6003; + name: 'InvalidFeeRecipient'; + msg: 'The specified fee recipient does not match the address in the instance accound'; + }, + { + code: 6004; + name: 'RelayingToChainDisabled'; + msg: 'Relaying to the specified chain is disabled'; + }, + { + code: 6257; + name: 'FeeRecipientCannotBeDefault'; + msg: 'The fee recipient cannot be the default address (0x0)'; + }, + { + code: 6258; + name: 'NotAuthorized'; + msg: 'Must be owner or assistant'; + }, + ]; +}; + +export const IDL: NttQuoter = { + version: '0.1.0', + name: 'ntt_quoter', + instructions: [ + { + name: 'requestRelay', + accounts: [ + { + name: 'payer', + isMut: true, + isSigner: true, + }, + { + name: 'instance', + isMut: false, + isSigner: false, + }, + { + name: 'registeredChain', + isMut: false, + isSigner: false, + }, + { + name: 'outboxItem', + isMut: false, + isSigner: false, + }, + { + name: 'relayRequest', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'RequestRelayArgs', + }, + }, + ], + }, + { + name: 'closeRelay', + accounts: [ + { + name: 'authority', + isMut: false, + isSigner: true, + }, + { + name: 'instance', + isMut: false, + isSigner: false, + }, + { + name: 'feeRecipient', + isMut: true, + isSigner: false, + }, + { + name: 'relayRequest', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [], + }, + { + name: 'initialize', + accounts: [ + { + name: 'owner', + isMut: true, + isSigner: true, + }, + { + name: 'instance', + isMut: true, + isSigner: false, + }, + { + name: 'feeRecipient', + isMut: false, + isSigner: false, + }, + { + name: 'programData', + isMut: true, + isSigner: false, + docs: [ + 'We use the program data to make sure this owner is the upgrade authority (the true owner,', + 'who deployed this program).', + ], + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [], + }, + { + name: 'setAssistant', + accounts: [ + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'instance', + isMut: true, + isSigner: false, + }, + { + name: 'assistant', + isMut: false, + isSigner: false, + isOptional: true, + }, + ], + args: [], + }, + { + name: 'setFeeRecipient', + accounts: [ + { + name: 'owner', + isMut: false, + isSigner: true, + }, + { + name: 'instance', + isMut: true, + isSigner: false, + }, + { + name: 'feeRecipient', + isMut: false, + isSigner: false, + }, + ], + args: [], + }, + { + name: 'registerChain', + accounts: [ + { + name: 'authority', + isMut: true, + isSigner: true, + }, + { + name: 'instance', + isMut: false, + isSigner: false, + }, + { + name: 'registeredChain', + isMut: true, + isSigner: false, + }, + { + name: 'systemProgram', + isMut: false, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'RegisterChainArgs', + }, + }, + ], + }, + { + name: 'updateSolPrice', + accounts: [ + { + name: 'authority', + isMut: false, + isSigner: true, + }, + { + name: 'instance', + isMut: false, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'UpdateSolPriceArgs', + }, + }, + ], + }, + { + name: 'updateChainPrices', + accounts: [ + { + name: 'authority', + isMut: false, + isSigner: true, + }, + { + name: 'instance', + isMut: false, + isSigner: false, + }, + { + name: 'registeredChain', + isMut: true, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'UpdateChainPricesArgs', + }, + }, + ], + }, + { + name: 'updateChainParams', + accounts: [ + { + name: 'authority', + isMut: false, + isSigner: true, + }, + { + name: 'instance', + isMut: false, + isSigner: false, + }, + { + name: 'registeredChain', + isMut: true, + isSigner: false, + }, + ], + args: [ + { + name: 'args', + type: { + defined: 'UpdateChainParamsArgs', + }, + }, + ], + }, + ], + accounts: [ + { + name: 'instance', + type: { + kind: 'struct', + fields: [ + { + name: 'owner', + type: 'publicKey', + }, + { + name: 'assistant', + type: 'publicKey', + }, + { + name: 'feeRecipient', + type: 'publicKey', + }, + { + name: 'solPrice', + type: 'u64', + }, + ], + }, + }, + { + name: 'registeredChain', + type: { + kind: 'struct', + fields: [ + { + name: 'bump', + type: 'u8', + }, + { + name: 'maxGasDropoff', + type: 'u64', + }, + { + name: 'basePrice', + type: 'u64', + }, + { + name: 'nativePrice', + type: 'u64', + }, + { + name: 'gasPrice', + type: 'u64', + }, + ], + }, + }, + { + name: 'relayRequest', + type: { + kind: 'struct', + fields: [ + { + name: 'requestedGasDropoff', + type: 'u64', + }, + ], + }, + }, + ], + types: [ + { + name: 'RegisterChainArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'chainId', + type: 'u16', + }, + ], + }, + }, + { + name: 'RequestRelayArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'gasDropoff', + type: 'u64', + }, + { + name: 'maxFee', + type: 'u64', + }, + ], + }, + }, + { + name: 'UpdateSolPriceArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'solPrice', + type: 'u64', + }, + ], + }, + }, + { + name: 'UpdateChainPricesArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'nativePrice', + type: 'u64', + }, + { + name: 'gasPrice', + type: 'u64', + }, + ], + }, + }, + { + name: 'UpdateChainParamsArgs', + type: { + kind: 'struct', + fields: [ + { + name: 'maxGasDropoff', + type: 'u64', + }, + { + name: 'basePrice', + type: 'u64', + }, + ], + }, + }, + ], + errors: [ + { + code: 6001, + name: 'ExceedsUserMaxFee', + msg: 'Relay fees exceeds specified max', + }, + { + code: 6002, + name: 'ExceedsMaxGasDropoff', + msg: 'Requested gas dropoff exceeds max allowed for chain', + }, + { + code: 6003, + name: 'InvalidFeeRecipient', + msg: 'The specified fee recipient does not match the address in the instance accound', + }, + { + code: 6004, + name: 'RelayingToChainDisabled', + msg: 'Relaying to the specified chain is disabled', + }, + { + code: 6257, + name: 'FeeRecipientCannotBeDefault', + msg: 'The fee recipient cannot be the default address (0x0)', + }, + { + code: 6258, + name: 'NotAuthorized', + msg: 'Must be owner or assistant', + }, + ], +}; diff --git a/wormhole-connect/src/routes/ntt/types.ts b/wormhole-connect/src/routes/ntt/types.ts new file mode 100644 index 000000000..c5d46d1f4 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/types.ts @@ -0,0 +1,5 @@ +export type InboundQueuedTransfer = { + recipient: string; + amount: string; + rateLimitExpiryTimestamp: number; +}; diff --git a/wormhole-connect/src/routes/ntt/utils.ts b/wormhole-connect/src/routes/ntt/utils.ts new file mode 100644 index 000000000..70bdf6f0b --- /dev/null +++ b/wormhole-connect/src/routes/ntt/utils.ts @@ -0,0 +1,77 @@ +import { ChainId, ChainName } from '@wormhole-foundation/wormhole-connect-sdk'; +import { keccak256 } from 'ethers/lib/utils'; +import { NttManagerMessage } from './payloads/common'; +import { NativeTokenTransfer } from './payloads/transfers'; +import { WormholeTransceiverMessage } from './payloads/wormhole'; +import config from 'config'; + +export const getNttManagerMessageDigest = ( + emitterChain: ChainName | ChainId, + message: NttManagerMessage, +): string => { + const chainIdBuffer = Buffer.alloc(2); + chainIdBuffer.writeUInt16BE(config.wh.toChainId(emitterChain)); + const serialized = NttManagerMessage.serialize( + message, + NativeTokenTransfer.serialize, + ); + const digest = keccak256(Buffer.concat([chainIdBuffer, serialized])); + return digest; +}; + +export const parseWormholeTransceiverMessage = ( + message: string | Buffer, +): WormholeTransceiverMessage => { + const buffer = Buffer.isBuffer(message) + ? message + : Buffer.from(message.slice(2), 'hex'); + return WormholeTransceiverMessage.deserialize(buffer, (a) => + NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize), + ); +}; + +export interface WormholeTransceiverInstruction { + shouldSkipRelayerSend: boolean; +} + +export const encodeWormholeTransceiverInstruction = ( + instruction: WormholeTransceiverInstruction, +): Buffer => { + const buffer = Buffer.alloc(1); + buffer.writeUInt8(instruction.shouldSkipRelayerSend ? 1 : 0); + return buffer; +}; + +export interface TransceiverInstruction { + index: number; + payload: Buffer; +} + +export const encodeTransceiverInstruction = ( + instruction: TransceiverInstruction, +): Buffer => { + if (instruction.payload.length > 255) { + throw new Error(`PayloadTooLong: ${instruction.payload.length}`); + } + const payloadLength = Buffer.from([instruction.payload.length]); + const indexBuffer = Buffer.from([instruction.index]); + return Buffer.concat([indexBuffer, payloadLength, instruction.payload]); +}; + +export const encodeTransceiverInstructions = ( + instructions: TransceiverInstruction[], +): Buffer => { + if (instructions.length > 255) { + throw new Error(`PayloadTooLong: ${instructions.length}`); + } + + const instructionsLength = Buffer.from([instructions.length]); + let encoded = Buffer.alloc(0); + + for (let i = 0; i < instructions.length; i++) { + const innerEncoded = encodeTransceiverInstruction(instructions[i]); + encoded = Buffer.concat([encoded, innerEncoded]); + } + + return Buffer.concat([instructionsLength, encoded]); +}; diff --git a/wormhole-connect/src/routes/operator.ts b/wormhole-connect/src/routes/operator.ts index 141b317fa..b28cf55f7 100644 --- a/wormhole-connect/src/routes/operator.ts +++ b/wormhole-connect/src/routes/operator.ts @@ -24,6 +24,8 @@ import { TransferDisplayData, TransferInfoBaseParams, TransferDestInfo, + NttRelayingType, + RelayerFee, } from './types'; import { CCTPManualRoute, @@ -34,6 +36,9 @@ import { getTokenById, isEqualCaseInsensitive } from 'utils'; import { ETHBridge } from './porticoBridge/ethBridge'; import { wstETHBridge } from './porticoBridge/wstETHBridge'; import { TokenPrices } from 'store/tokenPrices'; +import { NttManual, NttRelay } from './ntt'; +import { getMessageEvm as getNttMessageEvm } from './ntt/platforms/evm'; +import { getMessageSolana as getNttMessageSolana } from './ntt/platforms/solana'; export class Operator { getRoute(route: Route): RouteAbstract { @@ -65,6 +70,12 @@ export class Operator { case Route.wstETHBridge: { return new wstETHBridge(); } + case Route.NttManual: { + return new NttManual(); + } + case Route.NttRelay: { + return new NttRelay(); + } default: { throw new Error(`${route} is not a valid route`); } @@ -96,6 +107,36 @@ export class Operator { return Route.CCTPRelay; else return Route.CCTPManual; } + + // Check if is Ntt Route (NttRelay or NttManual) + if ( + config.tokensArr.some(({ ntt }) => ntt && ntt.nttManager === receipt.to) + ) { + const { relayingType } = await getNttMessageEvm(txHash, chain, receipt); + return relayingType === NttRelayingType.Manual + ? Route.NttManual + : Route.NttRelay; + } + } + + if (chain === 'solana') { + // Check if is Ntt Route (NttRelay or NttManual) + const connection = solanaContext().connection; + if (!connection) throw new Error('Connection not found'); + const tx = await connection.getParsedTransaction(txHash); + if (!tx) throw new Error('Transaction not found'); + if ( + tx.transaction.message.instructions.some((ix) => + config.tokensArr.some( + ({ ntt }) => ntt && ntt.nttManager === ix.programId.toString(), + ), + ) + ) { + const { relayingType } = await getNttMessageSolana(txHash); + return relayingType === NttRelayingType.Manual + ? Route.NttManual + : Route.NttRelay; + } } if (chain === 'solana') { @@ -521,7 +562,7 @@ export class Operator { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise { + ): Promise { const r = this.getRoute(route); return r.getRelayerFee(sourceChain, destChain, token, destToken); } diff --git a/wormhole-connect/src/routes/porticoBridge/porticoBridge.ts b/wormhole-connect/src/routes/porticoBridge/porticoBridge.ts index cefeb7af3..de119599c 100644 --- a/wormhole-connect/src/routes/porticoBridge/porticoBridge.ts +++ b/wormhole-connect/src/routes/porticoBridge/porticoBridge.ts @@ -14,6 +14,7 @@ import { SignedTokenTransferMessage, TransferDisplayData, TransferInfoBaseParams, + RelayerFee, } from '../types'; import { fetchGlobalTx, fetchVaa, getEmitterAndSequence } from 'utils/vaa'; import { hexZeroPad, hexlify, parseUnits } from 'ethers/lib/utils.js'; @@ -367,10 +368,6 @@ export abstract class PorticoBridge extends BaseRoute { return BigNumber.from(0); } - getMinSendAmount(routeOptions: PorticoBridgeState): number { - return 0; - } - getMaxSendAmount(): number { return this.maxAmount; } @@ -566,7 +563,7 @@ export abstract class PorticoBridge extends BaseRoute { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise { + ): Promise { if (!destToken) { throw new Error('destToken is required'); } @@ -593,7 +590,10 @@ export abstract class PorticoBridge extends BaseRoute { if (response.status !== 200) { throw new Error(`Error getting relayer fee: ${response.statusText}`); } - return BigNumber.from(response.data.fee); + return { + fee: BigNumber.from(response.data.fee), + feeToken: finalToken.tokenId, + }; } async getForeignAsset( diff --git a/wormhole-connect/src/routes/relay/relay.ts b/wormhole-connect/src/routes/relay/relay.ts index 218a64271..0f423a718 100644 --- a/wormhole-connect/src/routes/relay/relay.ts +++ b/wormhole-connect/src/routes/relay/relay.ts @@ -35,6 +35,7 @@ import { BridgeRoute } from '../bridge/bridge'; import { toDecimals, toFixedDecimals } from '../../utils/balance'; import { RelayTransferMessage, + RelayerFee, SignedRelayTransferMessage, TransferDestInfo, TransferDisplayData, @@ -102,12 +103,13 @@ export class RelayRoute extends BridgeRoute implements RelayAbstract { const tokenId = getWrappedTokenId(tokenConfig); let relayerFee; try { - relayerFee = await this.getRelayerFee( + const result = await this.getRelayerFee( sourceChain, destChain, sourceToken, destToken, ); + relayerFee = result?.fee; } catch (e) { console.error(e); } @@ -514,14 +516,15 @@ export class RelayRoute extends BridgeRoute implements RelayAbstract { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise { + ): Promise { const context: any = config.wh.getContext(sourceChain); const tokenConfig = config.tokens[token]; if (!tokenConfig) throw new Error('could not get token config'); const tokenId = tokenConfig.tokenId || getWrappedTokenId(tokenConfig); - return context.getRelayerFee + const fee = context.getRelayerFee ? await context.getRelayerFee(sourceChain, destChain, tokenId) : BigNumber.from(0); + return { fee, feeToken: tokenId }; } async getTransferSourceInfo({ diff --git a/wormhole-connect/src/routes/tbtc/tbtc.ts b/wormhole-connect/src/routes/tbtc/tbtc.ts index 7cbe1fe11..dcb6f69aa 100644 --- a/wormhole-connect/src/routes/tbtc/tbtc.ts +++ b/wormhole-connect/src/routes/tbtc/tbtc.ts @@ -22,6 +22,7 @@ import { TokenTransferMessage, SignedTokenTransferMessage, TBTCMessage, + RelayerFee, } from '../types'; import { adaptParsedMessage } from '../utils'; import { @@ -162,10 +163,6 @@ export class TBTCRoute extends BaseRoute { throw new Error('not implemented'); } - getMinSendAmount(routeOptions: any): number { - return 0; - } - async send( token: TokenId | 'native', amount: string, @@ -417,8 +414,8 @@ export class TBTCRoute extends BaseRoute { destChain: ChainName | ChainId, token: string, destToken: string, - ): Promise { - return BigNumber.from(0); + ): Promise { + return null; } async getForeignAsset( diff --git a/wormhole-connect/src/routes/types.ts b/wormhole-connect/src/routes/types.ts index 5ec453904..bcfcd97c8 100644 --- a/wormhole-connect/src/routes/types.ts +++ b/wormhole-connect/src/routes/types.ts @@ -1,6 +1,8 @@ import { Route } from 'config/types'; import { ParsedMessage, ParsedRelayerMessage } from '../utils/sdk'; import { TokenPrices } from 'store/tokenPrices'; +import { BigNumber } from 'ethers'; +import { TokenId } from '@wormhole-foundation/wormhole-connect-sdk'; export type TokenTransferMessage = ParsedMessage; export type RelayTransferMessage = ParsedRelayerMessage; @@ -11,17 +13,42 @@ export type ManualCCTPMessage = CCTPMessage & ParsedMessage; export type RelayCCTPMessage = CCTPMessage & ParsedRelayerMessage; export type UnsignedCCTPMessage = ManualCCTPMessage | RelayCCTPMessage; export type TBTCMessage = TokenTransferMessage & { to: string }; +export enum NttRelayingType { + Standard, + Special, + Manual, +} +export type UnsignedNttMessage = ParsedMessage & { + recipientNttManager: string; + messageDigest: string; + relayerFee: string; + relayingType: NttRelayingType; +}; export type UnsignedMessage = | TokenTransferMessage | RelayTransferMessage | UnsignedCCTPMessage - | TBTCMessage; + | TBTCMessage + | UnsignedNttMessage; + +export const isUnsignedNttMessage = ( + message: UnsignedMessage, +): message is UnsignedNttMessage => + typeof message === 'object' && + 'recipientNttManager' in message && + 'messageDigest' in message && + 'relayerFee' in message && + 'relayingType' in message; export type SignedTokenTransferMessage = TokenTransferMessage & { vaa: string }; // hex encoded vaa bytes export type SignedRelayTransferMessage = RelayTransferMessage & { vaa: string }; // hex encoded vaa bytes +export type SignedNttMessage = UnsignedNttMessage & { + vaa: string; +}; // hex encoded vaa bytes export type SignedWormholeMessage = | SignedTokenTransferMessage - | SignedRelayTransferMessage; + | SignedRelayTransferMessage + | SignedNttMessage; export type SignedManualCCTPMessage = ManualCCTPMessage & { attestation: string; }; @@ -41,6 +68,10 @@ export const isSignedCCTPMessage = ( typeof message === 'object' && 'message' in message && 'attestation' in message; +export const isSignedNttMessage = ( + message: SignedMessage, +): message is SignedNttMessage => + isSignedWormholeMessage(message) && isUnsignedNttMessage(message); export interface TransferInfoBaseParams { txData: ParsedMessage | ParsedRelayerMessage; @@ -70,3 +101,8 @@ export type TransferDestInfo = { }; export type TransferDisplayData = NestedRow[]; + +export interface RelayerFee { + fee: BigNumber; + feeToken: TokenId | 'native'; +} diff --git a/wormhole-connect/src/routes/utils.ts b/wormhole-connect/src/routes/utils.ts index 5e18be269..683424110 100644 --- a/wormhole-connect/src/routes/utils.ts +++ b/wormhole-connect/src/routes/utils.ts @@ -16,7 +16,7 @@ import { } from 'utils/sdk'; import { getTokenById } from 'utils'; import { CHAIN_ID_ETH } from '@certusone/wormhole-sdk/lib/esm/utils'; -import { TokenConfig } from 'config/types'; +import { Route, TokenConfig } from 'config/types'; // adapts the sdk returned parsed message to the type that // wh connect uses @@ -89,3 +89,7 @@ export const isIlliquidDestToken = ( } return false; }; + +export const isNttRoute = (route?: Route) => { + return route === Route.NttManual || route === Route.NttRelay; +}; diff --git a/wormhole-connect/src/store/helpers.ts b/wormhole-connect/src/store/helpers.ts index b45915c13..f9ebd0a38 100644 --- a/wormhole-connect/src/store/helpers.ts +++ b/wormhole-connect/src/store/helpers.ts @@ -2,6 +2,7 @@ export type DataWrapper = { data: T | null; error: any | null; isFetching: boolean; + receivedAt: string | null; }; export function getEmptyDataWrapper() { @@ -9,6 +10,7 @@ export function getEmptyDataWrapper() { data: null, error: null, isFetching: false, + receivedAt: null, }; } @@ -17,6 +19,7 @@ export function receiveDataWrapper(data: T): DataWrapper { data, error: null, isFetching: false, + receivedAt: new Date().toISOString(), }; } @@ -25,6 +28,7 @@ export function errorDataWrapper(error: string): DataWrapper { data: null, error, isFetching: false, + receivedAt: null, }; } @@ -33,5 +37,6 @@ export function fetchDataWrapper() { data: null, error: null, isFetching: true, + receivedAt: null, }; } diff --git a/wormhole-connect/src/store/index.ts b/wormhole-connect/src/store/index.ts index bbb302436..ee8b8f65d 100644 --- a/wormhole-connect/src/store/index.ts +++ b/wormhole-connect/src/store/index.ts @@ -6,6 +6,7 @@ import routerReducer from './router'; import walletReducer from './wallet'; import porticoBridgeReducer from './porticoBridge'; import tokenPricesReducer from './tokenPrices'; +import nttReducer from './ntt'; export const store = configureStore({ reducer: { @@ -16,6 +17,7 @@ export const store = configureStore({ relay: relayReducer, porticoBridge: porticoBridgeReducer, tokenPrices: tokenPricesReducer, + ntt: nttReducer, }, }); diff --git a/wormhole-connect/src/store/ntt.ts b/wormhole-connect/src/store/ntt.ts new file mode 100644 index 000000000..1db443d63 --- /dev/null +++ b/wormhole-connect/src/store/ntt.ts @@ -0,0 +1,40 @@ +import { createSlice, PayloadAction } from '@reduxjs/toolkit'; +import { + DataWrapper, + getEmptyDataWrapper, + receiveDataWrapper, +} from './helpers'; +import { InboundQueuedTransfer } from 'routes/ntt/types'; + +export interface NttState { + inboundQueuedTransfer: DataWrapper; +} + +const initialState: NttState = { + inboundQueuedTransfer: getEmptyDataWrapper(), +}; + +export const nttSlice = createSlice({ + name: 'ntt', + initialState, + reducers: { + setInboundQueuedTransfer: ( + state: NttState, + { payload }: PayloadAction, + ) => { + state.inboundQueuedTransfer = receiveDataWrapper(payload); + }, + resetInboundQueuedTransfer: (state: NttState) => { + state.inboundQueuedTransfer = getEmptyDataWrapper(); + }, + clearNtt: () => initialState, + }, +}); + +export const { + setInboundQueuedTransfer, + resetInboundQueuedTransfer, + clearNtt, +} = nttSlice.actions; + +export default nttSlice.reducer; diff --git a/wormhole-connect/src/store/redeem.ts b/wormhole-connect/src/store/redeem.ts index 18e8db19d..71b1d99ea 100644 --- a/wormhole-connect/src/store/redeem.ts +++ b/wormhole-connect/src/store/redeem.ts @@ -1,7 +1,8 @@ import { createSlice, PayloadAction } from '@reduxjs/toolkit'; import { ParsedMessage, ParsedRelayerMessage } from 'utils/sdk'; -import { SignedMessage, TransferDestInfo } from 'routes'; +import { UnsignedNttMessage, SignedMessage, TransferDestInfo } from 'routes'; import { Route } from 'config/types'; +import { DeliveryStatus } from '@certusone/wormhole-sdk/lib/esm/relayer'; export enum MessageType { BRIDGE = 1, @@ -9,7 +10,7 @@ export enum MessageType { } export interface RedeemState { - txData: ParsedMessage | ParsedRelayerMessage | undefined; + txData: ParsedMessage | ParsedRelayerMessage | UnsignedNttMessage | undefined; signedMessage: SignedMessage | undefined; sendTx: string; redeemTx: string; @@ -17,6 +18,7 @@ export interface RedeemState { isVaaEnqueued: boolean; route: Route | undefined; transferDestInfo: TransferDestInfo | undefined; + deliveryStatus: DeliveryStatus | undefined; } const initialState: RedeemState = { @@ -28,6 +30,7 @@ const initialState: RedeemState = { isVaaEnqueued: false, route: undefined, transferDestInfo: undefined, + deliveryStatus: undefined, }; export const redeemSlice = createSlice({ @@ -36,7 +39,11 @@ export const redeemSlice = createSlice({ reducers: { setTxDetails: ( state: RedeemState, - { payload }: PayloadAction, + { + payload, + }: PayloadAction< + ParsedMessage | ParsedRelayerMessage | UnsignedNttMessage + >, ) => { state.txData = payload; }, @@ -79,6 +86,12 @@ export const redeemSlice = createSlice({ ) => { state.signedMessage = payload; }, + setDeliveryStatus: ( + state: RedeemState, + { payload }: PayloadAction, + ) => { + state.deliveryStatus = payload; + }, }, }); @@ -92,6 +105,7 @@ export const { clearRedeem, setRoute, setSignedMessage, + setDeliveryStatus, } = redeemSlice.actions; export default redeemSlice.reducer; diff --git a/wormhole-connect/src/store/transferInput.ts b/wormhole-connect/src/store/transferInput.ts index c4aaf4ced..e9083f614 100644 --- a/wormhole-connect/src/store/transferInput.ts +++ b/wormhole-connect/src/store/transferInput.ts @@ -1,5 +1,9 @@ import { createSlice, PayloadAction } from '@reduxjs/toolkit'; -import { ChainName, Context } from '@wormhole-foundation/wormhole-connect-sdk'; +import { + ChainName, + ChainId, + Context, +} from '@wormhole-foundation/wormhole-connect-sdk'; import { BigNumber } from 'ethers'; import config from 'config'; import { Route, TokenConfig } from 'config/types'; @@ -55,6 +59,19 @@ export const getNativeVersionOfToken = ( ); }; +// get the token key for the NTT token for a given group and chain +export const getNttToken = ( + groupId: string, + chain: ChainName | ChainId, +): string => { + return ( + Object.entries(config.tokens) + .map(([key, t]) => t) + .find((t) => t.ntt?.groupId === groupId && t.nativeChain === chain) + ?.key || '' + ); +}; + export const accessChainBalances = ( balances: WalletBalances | undefined, walletAddress: WalletAddress | undefined, @@ -199,6 +216,8 @@ const performModificationsIfFromChainChanged = (state: TransferInputState) => { if (tokenConfig.nativeChain !== fromChain) { state.token = getNativeVersionOfToken(tokenConfig.symbol, fromChain!); } + } else if (tokenConfig.ntt && tokenConfig.nativeChain !== fromChain) { + state.token = getNttToken(tokenConfig.ntt.groupId, fromChain!); } } }; @@ -225,6 +244,8 @@ const performModificationsIfToChainChanged = (state: TransferInputState) => { if (tokenConfig.nativeChain !== toChain) { state.destToken = getNativeVersionOfToken(tokenConfig.symbol, toChain!); } + } else if (tokenConfig.ntt && tokenConfig.nativeChain !== toChain) { + state.destToken = getNttToken(tokenConfig.ntt.groupId, toChain!); } } }; @@ -247,6 +268,8 @@ const establishRoute = (state: TransferInputState) => { Route.TBTC, Route.ETHBridge, Route.wstETHBridge, + Route.NttRelay, + Route.NttManual, Route.Relay, Route.Bridge, ]; diff --git a/wormhole-connect/src/utils/index.ts b/wormhole-connect/src/utils/index.ts index 9b9671319..fa69975f1 100644 --- a/wormhole-connect/src/utils/index.ts +++ b/wormhole-connect/src/utils/index.ts @@ -1,5 +1,5 @@ import { useEffect, useRef } from 'react'; -import { BigNumber, BigNumberish, utils } from 'ethers'; +import { BigNumber, BigNumberish, ethers, utils } from 'ethers'; import { isHexString } from 'ethers/lib/utils.js'; import { isValidTransactionDigest, SUI_TYPE_ARG } from '@mysten/sui.js'; import { @@ -321,3 +321,20 @@ export const calculateUSDPrice = ( } return ''; }; + +export const tryParseErrorMessage = ( + iface: ethers.utils.Interface, + error: any, +): string | undefined => { + const errorData = error?.error?.data?.originalError?.data; + if (!errorData) return ''; + try { + return iface.parseError(errorData)?.name || undefined; + } catch { + return undefined; + } +}; + +export const removeDust = (amount: BigNumber, decimals: number): BigNumber => { + return deNormalizeAmount(normalizeAmount(amount, decimals), decimals); +}; diff --git a/wormhole-connect/src/utils/transferValidation.ts b/wormhole-connect/src/utils/transferValidation.ts index 1db589504..ea1c95a91 100644 --- a/wormhole-connect/src/utils/transferValidation.ts +++ b/wormhole-connect/src/utils/transferValidation.ts @@ -24,6 +24,7 @@ import { PorticoBridgeState } from 'store/porticoBridge'; import { DataWrapper } from 'store/helpers'; import { CCTPManual_CHAINS as CCTP_CHAINS } from 'routes/cctpManual'; import { CCTP_MAX_TRANSFER_LIMIT } from 'consts'; +import { isNttRoute } from 'routes'; export const validateFromChain = ( chain: ChainName | undefined, @@ -180,7 +181,8 @@ export const validateSolanaTokenAccount = ( route: Route | undefined, ): ValidationErr => { if (destChain !== 'solana') return ''; - if (route === Route.Relay || route === Route.TBTC) return ''; + if (route === Route.Relay || route === Route.TBTC || isNttRoute(route)) + return ''; if (!destTokenAddr) return ''; if (destTokenAddr && !solanaTokenAccount) { return 'The associated token account for this asset does not exist on Solana, you must create it first'; @@ -312,6 +314,10 @@ export const validateAll = async ( }; if (isAutomatic) { + if (route === Route.NttRelay) { + // Ntt does not support native gas drop-off + return baseValidations; + } return { ...baseValidations, toNativeToken: validateToNativeAmt(toNativeToken, maxSwapAmt), diff --git a/wormhole-connect/src/utils/vaa.ts b/wormhole-connect/src/utils/vaa.ts index 682f18803..a4d241249 100644 --- a/wormhole-connect/src/utils/vaa.ts +++ b/wormhole-connect/src/utils/vaa.ts @@ -45,6 +45,19 @@ export async function getUnsignedVaaEvm( sequence: BigNumberish; payload: string; }> { + const bridgeLog = await getWormholeLogEvm(chain, receipt); + const parsed = Implementation__factory.createInterface().parseLog(bridgeLog); + return { + emitterAddress: parsed.args.sender, + sequence: parsed.args.sequence, + payload: parsed.args.payload.toString('hex'), + }; +} + +export async function getWormholeLogEvm( + chain: ChainId | ChainName, + receipt: providers.TransactionReceipt, +): Promise { if (!isEvmChain(chain)) { throw new Error('Not an evm chain'); } @@ -52,20 +65,10 @@ export async function getUnsignedVaaEvm( const bridgeLogs = receipt.logs.filter((l: any) => { return l.address === core; }); - if (bridgeLogs.length === 0) { throw new Error(NO_VAA_FOUND); } - - const parsed = Implementation__factory.createInterface().parseLog( - bridgeLogs[0], - ); - - return { - emitterAddress: parsed.args.sender, - sequence: parsed.args.sequence, - payload: parsed.args.payload.toString('hex'), - }; + return bridgeLogs[0]; } export function getEmitterAndSequence( @@ -89,9 +92,20 @@ export function getEmitterAndSequence( export async function fetchVaa( txData: ParsedMessage | ParsedRelayerMessage, -): Promise { + bytesOnly: true, +): Promise; + +export async function fetchVaa( + txData: ParsedMessage | ParsedRelayerMessage, + bytesOnly?: false, +): Promise; + +export async function fetchVaa( + txData: ParsedMessage | ParsedRelayerMessage, + bytesOnly = false, +): Promise { try { - const vaa = await fetchVaaWormscan(txData); + const vaa = await fetchVaaWormscan(txData, bytesOnly); if (vaa === undefined) { console.warn('VAA not found in Wormscan'); @@ -102,13 +116,14 @@ export async function fetchVaa( 'Error fetching VAA from wormscan. Falling back to guardian.', e, ); - return await fetchVaaGuardian(txData); + return await fetchVaaGuardian(txData, bytesOnly); } } export async function fetchVaaWormscan( txData: ParsedMessage | ParsedRelayerMessage, -): Promise { + bytesOnly: boolean, +): Promise { // return if the number of block confirmations hasn't been met const chainName = config.wh.toChainName(txData.fromChain); const { finalityThreshold } = config.chains[chainName]! as any; @@ -127,6 +142,7 @@ export async function fetchVaaWormscan( if (!response.data.data) return; const data = response.data.data; const vaa = utils.base64.decode(data.vaa); + if (bytesOnly) return vaa; const parsed = parseTokenTransferVaa(vaa); const vaaData: ParsedVaa = { @@ -161,7 +177,8 @@ export async function fetchVaaWormscan( export async function fetchVaaGuardian( txData: ParsedMessage | ParsedRelayerMessage, -): Promise { + bytesOnly: boolean, +): Promise { // return if the number of block confirmations hasn't been met const chainName = config.wh.toChainName(txData.fromChain); const { finalityThreshold } = config.chains[chainName]! as any; @@ -192,6 +209,9 @@ export async function fetchVaaGuardian( if (!vaa) { throw new Error('Failed to fetch VAA from all hosts'); } + if (bytesOnly) { + return vaa; + } const parsed = parseTokenTransferVaa(vaa); diff --git a/wormhole-connect/src/utils/wallet/index.ts b/wormhole-connect/src/utils/wallet/index.ts index 9f635772f..409f15eba 100644 --- a/wormhole-connect/src/utils/wallet/index.ts +++ b/wormhole-connect/src/utils/wallet/index.ts @@ -107,6 +107,7 @@ export const signAndSendTransaction = async ( chain: ChainName, transaction: SendResult, walletType: TransferWallet, + options: any = {}, ): Promise => { const chainConfig = config.chains[chain]!; @@ -121,7 +122,7 @@ export const signAndSendTransaction = async ( } case Context.SOLANA: { const { signAndSendTransaction } = await import('utils/wallet/solana'); - const tx = await signAndSendTransaction(transaction, wallet); + const tx = await signAndSendTransaction(transaction, wallet, options); return tx.id; } case Context.SUI: { diff --git a/wormhole-connect/src/views/Bridge/Bridge.tsx b/wormhole-connect/src/views/Bridge/Bridge.tsx index 7cdcc6441..03a79d623 100644 --- a/wormhole-connect/src/views/Bridge/Bridge.tsx +++ b/wormhole-connect/src/views/Bridge/Bridge.tsx @@ -47,6 +47,8 @@ import { wstETHBridge } from 'routes/porticoBridge/wstETHBridge'; import { usePorticoSwapInfo } from 'hooks/usePorticoSwapInfo'; import { usePorticoRelayerFee } from 'hooks/usePorticoRelayerFee'; import { useFetchTokenPrices } from 'hooks/useFetchTokenPrices'; +import NttInboundCapacityWarning from './NttInboundCapacityWarning'; +import { isNttRoute } from 'routes/utils'; const useStyles = makeStyles()((_theme) => ({ spacer: { @@ -321,7 +323,7 @@ function Bridge() { - + {isNttRoute(route) && } diff --git a/wormhole-connect/src/views/Bridge/Inputs/TokenWarnings.tsx b/wormhole-connect/src/views/Bridge/Inputs/TokenWarnings.tsx index e30c9efae..ab18aa3c0 100644 --- a/wormhole-connect/src/views/Bridge/Inputs/TokenWarnings.tsx +++ b/wormhole-connect/src/views/Bridge/Inputs/TokenWarnings.tsx @@ -18,6 +18,7 @@ import AlertBanner from 'components/AlertBanner'; import RouteOperator from 'routes/operator'; import { Route } from '../../../config/types'; import { CCTPManual_CHAINS as CCTP_CHAINS } from 'routes/cctpManual'; +import { isNttRoute } from 'routes'; const useStyles = makeStyles()((theme: any) => ({ associatedTokenWarning: { @@ -244,7 +245,13 @@ function TokenWarnings() { if (!toChain || !token || !receiving.address) return; // The tBTC associated token account will be created if it doesn't exist in the redeem tx - if (toChain === 'solana' && foreignAsset && route !== Route.TBTC) { + // The NTT ATA will be created if it doesn't exist in the redeem tx + if ( + toChain === 'solana' && + foreignAsset && + route !== Route.TBTC && + !isNttRoute(route) + ) { checkSolanaAssociatedTokenAccount(); } if (usdcAndNoCCTP) { diff --git a/wormhole-connect/src/views/Bridge/NttInboundCapacityWarning.tsx b/wormhole-connect/src/views/Bridge/NttInboundCapacityWarning.tsx new file mode 100644 index 000000000..275f8800e --- /dev/null +++ b/wormhole-connect/src/views/Bridge/NttInboundCapacityWarning.tsx @@ -0,0 +1,115 @@ +import React, { useEffect, useMemo, useState } from 'react'; +import AlertBanner from 'components/AlertBanner'; +import { NttManual } from 'routes/ntt'; +import { parseUnits } from 'ethers/lib/utils'; +import { getTokenDecimals } from 'utils'; +import { BigNumber } from 'ethers'; +import { getNttToken } from 'store/transferInput'; +import { useSelector } from 'react-redux'; +import { RootState } from 'store'; +import config from 'config'; + +function formatDuration(seconds: number) { + if (seconds < 60) { + return seconds === 1 ? `${seconds} second` : `${seconds} seconds`; + } else if (seconds < 3600) { + const minutes = Math.floor(seconds / 60); + return minutes === 1 ? `${minutes} minute` : `${minutes} minutes`; + } else { + const hours = Math.floor(seconds / 3600); + return hours === 1 ? `${hours} hour` : `${hours} hours`; + } +} + +const NttInboundCapacityWarning = () => { + const { fromChain, toChain, destToken, receiveAmount } = useSelector( + (state: RootState) => state.transferInput, + ); + const amount = receiveAmount.data || '0'; + const [capacity, setCapacity] = useState(undefined); + const [duration, setDuration] = useState(0); + const nttManagerAddress = config.tokens[destToken]?.ntt?.nttManager; + + useEffect(() => { + if (!toChain || !nttManagerAddress || !fromChain) return; + let active = true; + const fetchCapacity = async () => { + try { + const ntt = new NttManual(); + const duration = await ntt.getRateLimitDuration( + toChain, + nttManagerAddress, + ); + // if the rate limit duration 0, then rate limiting is disabled + if (duration === 0) { + if (active) { + setCapacity(undefined); + setDuration(0); + } + return; + } + const capacity = await ntt.getCurrentInboundCapacity( + toChain, + nttManagerAddress, + fromChain, + ); + if (active) { + setCapacity(capacity ? BigNumber.from(capacity) : undefined); + setDuration(duration); + } + } catch (error) { + console.error('Failed to fetch capacity:', error); + if (active) { + setCapacity(undefined); + setDuration(0); + } + } + }; + fetchCapacity(); + return () => { + active = false; + }; + }, [toChain, nttManagerAddress, fromChain]); + + const showWarning = useMemo(() => { + if ( + !destToken || + !amount || + !toChain || + !capacity || + !duration || + !fromChain + ) + return false; + const groupId = config.tokens[destToken]?.ntt?.groupId; + if (!groupId) return false; + const destTokenKey = getNttToken(groupId, toChain); + const destTokenConfig = config.tokens[destTokenKey]; + if (!destTokenConfig) return false; + // capacity is in destination token decimals, so we need to convert the amount to the same decimals + const decimals = getTokenDecimals( + config.wh.toChainId(toChain), + destTokenConfig.tokenId, + ); + const parsedAmount = parseUnits(Number(amount).toFixed(decimals), decimals); + const threshold = capacity.mul(95).div(100); // 95% of capacity + return parsedAmount.gt(threshold); + }, [destToken, amount, toChain]); + + if (!showWarning || !toChain) return null; + + const content = ( + <> + {`Your transfer to ${ + config.chains[toChain]?.displayName || 'UNKNOWN' + } may be delayed due to rate limits set by ${ + config.tokens[destToken]?.symbol || 'UNKNOWN' + }. If your transfer is delayed, you will need to return after ${formatDuration( + duration, + )} to complete the transfer. Please consider this before proceeding.`} + + ); + return ; +}; + +export default NttInboundCapacityWarning; diff --git a/wormhole-connect/src/views/Bridge/Preview.tsx b/wormhole-connect/src/views/Bridge/Preview.tsx index 631c7675e..497882c63 100644 --- a/wormhole-connect/src/views/Bridge/Preview.tsx +++ b/wormhole-connect/src/views/Bridge/Preview.tsx @@ -109,17 +109,16 @@ function Preview(props: { collapsed: boolean }) { const tokenConfig = token && config.tokens[token]; if (!tokenConfig) return; - const fee = await RouteOperator.getRelayerFee( + const result = await RouteOperator.getRelayerFee( route, fromChain, toChain, token, destToken, ); - const decimals = getTokenDecimals( - toChainId(fromChain), - tokenConfig.tokenId || 'native', - ); + if (result === null) return; + const { fee, feeToken } = result; + const decimals = getTokenDecimals(toChainId(fromChain), feeToken); const formattedFee = Number.parseFloat(toDecimals(fee, decimals, 6)); dispatch(setRelayerFee(formattedFee)); } catch (e: any) { diff --git a/wormhole-connect/src/views/Bridge/Send.tsx b/wormhole-connect/src/views/Bridge/Send.tsx index 62e98b469..c0721a6d0 100644 --- a/wormhole-connect/src/views/Bridge/Send.tsx +++ b/wormhole-connect/src/views/Bridge/Send.tsx @@ -39,6 +39,11 @@ import { validateSolanaTokenAccount } from '../../utils/transferValidation'; import { useDebounce } from 'use-debounce'; import { isPorticoRoute } from 'routes/porticoBridge/utils'; import { SWAP_ERROR } from 'routes/porticoBridge/consts'; +import { + DestinationContractIsPausedError, + NotEnoughCapacityError, + ContractIsPausedError, +} from 'routes/ntt/errors'; const useStyles = makeStyles()((theme) => ({ body: { @@ -102,12 +107,12 @@ function Send(props: { valid: boolean }) { try { const fromConfig = config.chains[fromChain!]; if (fromConfig?.context === Context.ETH) { - registerWalletSigner(fromChain!, TransferWallet.SENDING); const chainId = fromConfig.chainId; if (typeof chainId !== 'number') { throw new Error('invalid evm chain ID'); } await switchChain(chainId, TransferWallet.SENDING); + registerWalletSigner(fromChain!, TransferWallet.SENDING); } if (fromConfig?.context === Context.COSMOS) { await switchChain(fromConfig.chainId, TransferWallet.SENDING); @@ -159,6 +164,13 @@ function Send(props: { valid: boolean }) { ? 'Error due to insufficient token allowance, please try again' : e?.message === SWAP_ERROR ? SWAP_ERROR + : e?.message === NotEnoughCapacityError.MESSAGE + ? `This transfer would be rate-limited due to high volume on ${ + config.chains[transferInput.fromChain!]?.displayName + }, please try again later` + : e?.message === ContractIsPausedError.MESSAGE || + e?.message === DestinationContractIsPausedError.MESSAGE + ? e.message : 'Error with transfer, please try again', ); } diff --git a/wormhole-connect/src/views/Redeem/NttInboundQueued.tsx b/wormhole-connect/src/views/Redeem/NttInboundQueued.tsx new file mode 100644 index 000000000..0280e5e6a --- /dev/null +++ b/wormhole-connect/src/views/Redeem/NttInboundQueued.tsx @@ -0,0 +1,215 @@ +import InputContainer from 'components/InputContainer'; +import React, { useCallback, useEffect, useState } from 'react'; +import { useSelector } from 'react-redux'; +import { RootState } from 'store'; +import { isSignedNttMessage as isSignedNttMessage } from 'routes'; +import { NttManual, NttRelay } from 'routes/ntt'; +import Header from './Header'; +import { useDispatch } from 'react-redux'; +import Button from 'components/Button'; +import CircularProgress from '@mui/material/CircularProgress'; +import { setInboundQueuedTransfer } from 'store/ntt'; +import { + TransferWallet, + registerWalletSigner, + switchChain, +} from 'utils/wallet'; +import { Context } from '@wormhole-foundation/wormhole-connect-sdk'; +import WalletsModal from '../WalletModal'; +import AlertBanner from 'components/AlertBanner'; +import Spacer from 'components/Spacer'; +import { Route } from 'config/types'; +import { + InboundQueuedTransferNotFoundError, + InboundQueuedTransferStillQueuedError, + ContractIsPausedError, +} from 'routes/ntt/errors'; +import { setRedeemTx, setTransferComplete } from 'store/redeem'; +import { OPACITY } from 'utils/style'; +import { useTheme } from '@mui/material'; +import config from 'config'; + +const NttInboundQueued = () => { + const dispatch = useDispatch(); + const theme: any = useTheme(); + const route = useSelector((state: RootState) => state.redeem.route); + const wallet = useSelector((state: RootState) => state.wallet.receiving); + const signedMessage = useSelector( + (state: RootState) => state.redeem.signedMessage, + )!; + const inboundQueuedTransfer = useSelector( + (state: RootState) => state.ntt.inboundQueuedTransfer, + ); + + const checkConnection = useCallback(() => { + if (!isSignedNttMessage(signedMessage)) return; + const addr = wallet.address.toLowerCase(); + const curAddr = wallet.currentAddress.toLowerCase(); + return addr === curAddr; + }, [wallet, signedMessage]); + + const [inProgress, setInProgress] = useState(false); + const [sendError, setSendError] = useState(''); + const [isConnected, setIsConnected] = useState(checkConnection()); + const [openWalletModal, setWalletModal] = useState(false); + const [expired, setExpired] = useState(false); + const [rateLimitExpiry, setRateLimitExpiry] = useState(''); + + useEffect(() => { + if (!inboundQueuedTransfer.data) { + setExpired(true); + setRateLimitExpiry(''); + return; + } + const expiry = new Date( + inboundQueuedTransfer.data.rateLimitExpiryTimestamp * 1000, + ); + setRateLimitExpiry(expiry.toLocaleString()); + const now = new Date(); + if (now < expiry) { + setExpired(false); + const timeoutId = setTimeout( + () => setExpired(true), + expiry.getTime() - now.getTime(), + ); + return () => clearTimeout(timeoutId); + } else { + setExpired(true); + } + }, [inboundQueuedTransfer]); + + const connect = () => { + setWalletModal(true); + }; + + useEffect(() => { + setIsConnected(checkConnection()); + }, [wallet, checkConnection]); + + const handleClick = useCallback(async () => { + if (!isSignedNttMessage(signedMessage)) return; + const { toChain, recipientNttManager, messageDigest, recipient } = + signedMessage; + setInProgress(true); + const nttRoute = + route === Route.NttManual ? new NttManual() : new NttRelay(); + let tx: string | undefined; + try { + const toConfig = config.chains[toChain]!; + if (toConfig?.context === Context.ETH) { + await switchChain(toConfig.chainId, TransferWallet.RECEIVING); + registerWalletSigner(toChain, TransferWallet.RECEIVING); + } + tx = await nttRoute.completeInboundQueuedTransfer( + toChain, + recipientNttManager, + messageDigest, + recipient, + wallet.address, + ); + } catch (e: any) { + switch (e.message) { + case InboundQueuedTransferNotFoundError.MESSAGE: + case InboundQueuedTransferStillQueuedError.MESSAGE: + case ContractIsPausedError.MESSAGE: + setSendError(e.message); + break; + default: + setSendError('Error with transfer, please try again'); + break; + } + console.error(e); + } + if (tx !== undefined) { + try { + // Check that the transfer is not still queued + const inboundQueuedTransfer = await nttRoute.getInboundQueuedTransfer( + toChain, + recipientNttManager, + messageDigest, + ); + if (!inboundQueuedTransfer) { + dispatch(setInboundQueuedTransfer(undefined)); + dispatch(setRedeemTx(tx)); + const isTransferCompleted = await nttRoute.isTransferCompleted( + toChain, + signedMessage, + ); + dispatch(setTransferComplete(isTransferCompleted)); + } + } catch (e) { + console.error(e); + } + } + setInProgress(false); + }, [signedMessage, wallet, route]); + + return ( + <> + + <> +
+ {!expired ? ( +
+ {`Your transfer to ${ + config.chains[signedMessage.toChain]?.displayName || 'UNKNOWN' + } is delayed due to rate limits configured by ${ + config.tokens[signedMessage.receivedTokenKey]?.symbol || + 'UNKNOWN' + }. After the delay ends on ${ + rateLimitExpiry || 'UNKNOWN' + }, you will need to return to submit a new transaction to complete your transfer.`} +
+ ) : ( +
+ {`Your transfer to ${ + config.chains[signedMessage.toChain]?.displayName || 'UNKNOWN' + } was delayed due to rate limits configured by ${ + config.tokens[signedMessage.receivedTokenKey]?.symbol || + 'UNKNOWN' + }. You will need to submit a new transaction to complete your transfer.`} +
+ )} + + + + + {wallet.address ? ( + isConnected ? ( + + ) : ( + + ) + ) : ( + + )} + {openWalletModal && ( + setWalletModal(false)} + /> + )} + + ); +}; + +export default NttInboundQueued; diff --git a/wormhole-connect/src/views/Redeem/NttStepper.tsx b/wormhole-connect/src/views/Redeem/NttStepper.tsx new file mode 100644 index 000000000..7eba7c30d --- /dev/null +++ b/wormhole-connect/src/views/Redeem/NttStepper.tsx @@ -0,0 +1,63 @@ +import * as React from 'react'; +import { useSelector } from 'react-redux'; +import { RootState } from 'store'; +import Stepper from 'components/Stepper/Stepper'; +import SendFrom from './SendFrom'; +import SendTo from './SendTo'; +import BridgeComplete from './BridgeComplete'; +import NttInboundQueued from './NttInboundQueued'; +import RelayerDeliveryFailed from './RelayerDeliveryFailed'; +import { DeliveryStatus } from '@certusone/wormhole-sdk/lib/esm/relayer'; + +const SEND_FROM_STEP = 1; +const SEND_TO_STEP = 2; +const TRANSACTION_COMPLETE_STEP = 4; + +export default function NttStepper() { + const signedMessage = useSelector( + (state: RootState) => state.redeem.signedMessage, + ); + const deliveryStatus = useSelector( + (state: RootState) => state.redeem.deliveryStatus, + ); + const transferComplete = useSelector( + (state: RootState) => state.redeem.transferComplete, + ); + const inboundQueuedTransfer = useSelector( + (state: RootState) => state.ntt.inboundQueuedTransfer, + ); + + const deliveryFailed = deliveryStatus === DeliveryStatus.ReceiverFailure; + const isInboundQueued = !!inboundQueuedTransfer.data; + const showWarning = isInboundQueued || deliveryFailed; + + const activeStep = transferComplete + ? TRANSACTION_COMPLETE_STEP + : signedMessage || deliveryFailed + ? SEND_TO_STEP + : SEND_FROM_STEP; + + const steps = [ + { + label: 'Send from', + component: , + warningLine: showWarning, + }, + { + label: 'Send to', + component: deliveryFailed ? ( + + ) : isInboundQueued ? ( + + ) : ( + + ), + warningLabel: showWarning, + }, + { + label: 'Transaction complete', + component: , + }, + ]; + return ; +} diff --git a/wormhole-connect/src/views/Redeem/Redeem.tsx b/wormhole-connect/src/views/Redeem/Redeem.tsx index 0539053ec..090fa3d30 100644 --- a/wormhole-connect/src/views/Redeem/Redeem.tsx +++ b/wormhole-connect/src/views/Redeem/Redeem.tsx @@ -10,7 +10,7 @@ import { } from 'store/redeem'; import { sleep } from 'utils'; import { fetchIsVAAEnqueued } from 'utils/vaa'; -import { SignedMessage } from 'routes'; +import { SignedMessage, isNttRoute } from 'routes'; import RouteOperator from 'routes/operator'; import { ParsedMessage, ParsedRelayerMessage } from 'utils/sdk'; @@ -18,8 +18,11 @@ import PageHeader from 'components/PageHeader'; import Spacer from 'components/Spacer'; import ChainsTag from './Tag'; import Stepper from './Stepper'; +import NttStepper from './NttStepper'; import GovernorEnqueuedWarning from './GovernorEnqueuedWarning'; import config from 'config'; +import useDeliveryStatus from 'hooks/useDeliveryStatus'; +import useCheckInboundQueuedTransfer from 'hooks/useCheckInboundQueuedTransfer'; import useConfirmBeforeLeaving from 'utils/confirmBeforeLeaving'; @@ -50,7 +53,8 @@ function Redeem({ if ( !txData?.sendTx || !txData.emitterAddress || // no VAA exists, e.g. CCTP route - !!signedMessage // if we have the VAA, then it's not enqueued + !!signedMessage || // if we have the VAA, then it's not enqueued + isNttRoute(route) // NTT route doesn't use token bridge / governor ) { return; } @@ -72,7 +76,7 @@ function Redeem({ return () => { cancelled = true; }; - }, [txData, signedMessage, setIsVaaEnqueued]); + }, [txData, signedMessage, route, setIsVaaEnqueued]); // fetch the VAA useEffect(() => { @@ -86,8 +90,9 @@ function Redeem({ while (signed === undefined && !cancelled) { try { signed = await RouteOperator.getSignedMessage(route, txData); - } catch { + } catch (e) { signed = undefined; + console.log(e); } if (cancelled) { return; @@ -140,6 +145,9 @@ function Redeem({ }; }, [route, txData, transferComplete, setTransferComplete, signedMessage]); + useCheckInboundQueuedTransfer(); + useDeliveryStatus(); + return txData?.fromChain ? (
- + {isNttRoute(route) ? : }
) : ( <> diff --git a/wormhole-connect/src/views/Redeem/RelayerDeliveryFailed.tsx b/wormhole-connect/src/views/Redeem/RelayerDeliveryFailed.tsx new file mode 100644 index 000000000..cc76e902b --- /dev/null +++ b/wormhole-connect/src/views/Redeem/RelayerDeliveryFailed.tsx @@ -0,0 +1,62 @@ +import React from 'react'; +import { getChainConfig } from 'utils'; +import { makeStyles } from 'tss-react/mui'; +import InputContainer from 'components/InputContainer'; +import { OPACITY } from 'utils/style'; +import { Typography, useTheme } from '@mui/material'; +import { RootState } from 'store'; +import { useSelector } from 'react-redux'; +import Header from './Header'; + +const useStyles = makeStyles()((theme: any) => ({ + root: { + display: 'flex', + flexDirection: 'column', + gap: '8px', + marginTop: theme.spacing(1), + }, + link: { + color: theme.palette.text.primary, + textDecoration: 'underline', + cursor: 'pointer', + }, + revertString: { + wordWrap: 'break-word', + }, +})); + +const RelayerDeliveryFailed = () => { + const { classes } = useStyles(); + const theme: any = useTheme(); + const txData = useSelector((state: RootState) => state.redeem.txData)!; + const redeemTx = useSelector((state: RootState) => state.redeem.redeemTx); + const chainDisplayName = getChainConfig(txData.toChain).displayName; + return ( + +
+ + + ); +}; + +export default RelayerDeliveryFailed; diff --git a/wormhole-connect/src/views/Redeem/SendTo.tsx b/wormhole-connect/src/views/Redeem/SendTo.tsx index bf3c6eced..dec26313f 100644 --- a/wormhole-connect/src/views/Redeem/SendTo.tsx +++ b/wormhole-connect/src/views/Redeem/SendTo.tsx @@ -34,6 +34,9 @@ import { AssociatedTokenWarning } from '../Bridge/Inputs/TokenWarnings'; import { Route } from 'config/types'; import SwitchToManualClaim from './SwitchToManualClaim'; import { isPorticoRoute } from 'routes/porticoBridge/utils'; +import { isNttRoute, isSignedNttMessage } from 'routes'; +import { ContractIsPausedError, NttBase } from 'routes/ntt'; +import { setInboundQueuedTransfer } from 'store/ntt'; function AssociatedTokenAlert() { const dispatch = useDispatch(); @@ -196,32 +199,70 @@ function SendTo() { setClaimError('Your claim has failed, please try again'); throw new Error('invalid destination chain'); } + let txId: string | undefined; try { if ( chainConfig!.context === Context.ETH && typeof chainConfig.chainId === 'number' ) { - registerWalletSigner(txData.toChain, TransferWallet.RECEIVING); await switchChain(chainConfig.chainId, TransferWallet.RECEIVING); + registerWalletSigner(txData.toChain, TransferWallet.RECEIVING); } if (!signedMessage) { throw new Error('failed to get vaa, cannot redeem'); } - const txId = await RouteOperator.redeem( + txId = await RouteOperator.redeem( routeName, txData.toChain, signedMessage, wallet.address, ); - dispatch(setRedeemTx(txId)); - dispatch(setTransferComplete(true)); setInProgress(false); setClaimError(''); - } catch (e) { + } catch (e: any) { + if (e.message === ContractIsPausedError.MESSAGE) { + setClaimError('The contract is paused, please try again later'); + } setInProgress(false); setClaimError('Your claim has failed, please try again'); console.error(e); } + if (txId !== undefined) { + const route = RouteOperator.getRoute(routeName); + if ( + isNttRoute(route.TYPE) && + signedMessage && + isSignedNttMessage(signedMessage) + ) { + // The redeem may have resulted in the transfer being inbound queued + // so we need to check that before we set the transfer as complete + try { + const nttRoute = route as NttBase; + const inboundQueuedTransfer = await nttRoute.getInboundQueuedTransfer( + txData.toChain, + signedMessage.recipientNttManager, + signedMessage.messageDigest, + ); + if (inboundQueuedTransfer) { + dispatch(setInboundQueuedTransfer(inboundQueuedTransfer)); + } else { + const isTransferCompleted = await nttRoute.isTransferCompleted( + txData.toChain, + signedMessage, + ); + if (isTransferCompleted) { + dispatch(setRedeemTx(txId)); + dispatch(setTransferComplete(true)); + } + } + } catch (e) { + console.error(e); + } + } else { + dispatch(setRedeemTx(txId)); + dispatch(setTransferComplete(true)); + } + } }; // sometimes the ATA might be closed even after the transfer began From e35bc886a92b8dbcb7f6a45f582ca00e419897c9 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Wed, 27 Mar 2024 10:23:59 -0500 Subject: [PATCH 02/17] Use SDKv2 layouts for message parsing --- package-lock.json | 53 +++----- wormhole-connect/package.json | 2 +- .../src/routes/ntt/payloads/common.ts | 120 ------------------ .../src/routes/ntt/payloads/transfers.ts | 50 -------- .../src/routes/ntt/payloads/trimmedAmount.ts | 22 ---- .../src/routes/ntt/payloads/wormhole.ts | 5 - .../routes/ntt/platforms/evm/getMessage.ts | 38 +++--- .../routes/ntt/platforms/solana/getMessage.ts | 39 +++--- .../routes/ntt/platforms/solana/nttManager.ts | 32 ++--- wormhole-connect/src/routes/ntt/utils.ts | 32 ----- 10 files changed, 78 insertions(+), 315 deletions(-) delete mode 100644 wormhole-connect/src/routes/ntt/payloads/common.ts delete mode 100644 wormhole-connect/src/routes/ntt/payloads/transfers.ts delete mode 100644 wormhole-connect/src/routes/ntt/payloads/trimmedAmount.ts delete mode 100644 wormhole-connect/src/routes/ntt/payloads/wormhole.ts diff --git a/package-lock.json b/package-lock.json index 61ac29651..8f36744ac 100644 --- a/package-lock.json +++ b/package-lock.json @@ -13483,6 +13483,23 @@ "@xtuc/long": "4.2.2" } }, + "node_modules/@wormhole-foundation/sdk-base": { + "version": "0.5.2-beta.0", + "resolved": "https://registry.npmjs.org/@wormhole-foundation/sdk-base/-/sdk-base-0.5.2-beta.0.tgz", + "integrity": "sha512-K3GR/fsh07wlSoy/ugJooPT2hboi8jrQxJRVsrJhF2FIFYIVkcMORvUiIgDDhUbcMlX7jAt4Nl77bPcVoj3+tg==", + "dependencies": { + "@scure/base": "^1.1.3" + } + }, + "node_modules/@wormhole-foundation/sdk-definitions": { + "version": "0.5.2-beta.0", + "resolved": "https://registry.npmjs.org/@wormhole-foundation/sdk-definitions/-/sdk-definitions-0.5.2-beta.0.tgz", + "integrity": "sha512-/9S74lRgv8oGHW4A3RiGzlzwSWzFQBg9w93ePJcidB9XoUY54TgudCnCVOJkmDrVfSlAj1Iyqy+qjihbP+5uQA==", + "dependencies": { + "@noble/hashes": "^1.3.1", + "@wormhole-foundation/sdk-base": "0.5.2-beta.0" + } + }, "node_modules/@wormhole-foundation/wormhole-connect": { "resolved": "wormhole-connect", "link": true @@ -36608,7 +36625,7 @@ "@reduxjs/toolkit": "^1.9.1", "@solana/wallet-adapter-wallets": "^0.19.25", "@solana/web3.js": "^1.73.0", - "@wormhole-foundation/sdk-definitions": "^0.5.0", + "@wormhole-foundation/sdk-definitions": "^0.5.2-beta.0", "@xlabs-libs/wallet-aggregator-aptos": "^0.0.1-alpha.14", "@xlabs-libs/wallet-aggregator-core": "^0.0.1-alpha.18", "@xlabs-libs/wallet-aggregator-cosmos": "^0.0.1-alpha.14", @@ -36704,40 +36721,6 @@ "peerDependencies": { "@babel/core": "^7.0.0-0" } - }, - "wormhole-connect/node_modules/@wormhole-foundation/sdk-base": { - "version": "0.5.0", - "resolved": "https://registry.npmjs.org/@wormhole-foundation/sdk-base/-/sdk-base-0.5.0.tgz", - "integrity": "sha512-5+Y0Wrw6eihkbUqVpXDowvD3Xs3IIF0gvLK6JQ3xsuya/LiJeP8S7YdLVRjnGE5rEAvsf46yrgxuzy5hQ3xuVQ==", - "dependencies": { - "@scure/base": "^1.1.3" - } - }, - "wormhole-connect/node_modules/@wormhole-foundation/sdk-definitions": { - "version": "0.5.0", - "resolved": "https://registry.npmjs.org/@wormhole-foundation/sdk-definitions/-/sdk-definitions-0.5.0.tgz", - "integrity": "sha512-Qm8quIquf9Sx7SGUVxch9+EZRlkMdz9vYFLBUru+PCqxnHoVg0yobhUHCMi+9wn4n2BWU3F8UC/zv/VDJmMrGg==", - "dependencies": { - "@noble/hashes": "^1.3.1", - "@wormhole-foundation/sdk-base": "0.5.0" - } - }, - "wormhole-connect/node_modules/@xlabs-libs/wallet-aggregator-evm": { - "version": "0.0.1-alpha.37", - "resolved": "https://registry.npmjs.org/@xlabs-libs/wallet-aggregator-evm/-/wallet-aggregator-evm-0.0.1-alpha.37.tgz", - "integrity": "sha512-mtkIyWJeirLWZ5YfLXvas4/0sp9t7TfcNZ2MPm+Sseq3VcZeuaLDd58NwLfh3S3QYatC3koT6pOK8OYlNG5f0Q==", - "dependencies": { - "@ethersproject/abi": "^5.7.0", - "@ethersproject/abstract-provider": "^5.7.0", - "@ethersproject/bytes": "^5.7.0", - "@ethersproject/providers": "^5.7.2", - "@wagmi/core": "^1.4.13", - "@web3modal/standalone": "^2.2.1", - "@xlabs-libs/wallet-aggregator-core": "^0.0.1-alpha.18", - "ethers": "^5.7.2", - "versions": "^10.4.1", - "viem": "^1.20.3" - } } } } diff --git a/wormhole-connect/package.json b/wormhole-connect/package.json index 1cdea723a..b8caf2746 100644 --- a/wormhole-connect/package.json +++ b/wormhole-connect/package.json @@ -31,7 +31,7 @@ "@reduxjs/toolkit": "^1.9.1", "@solana/wallet-adapter-wallets": "^0.19.25", "@solana/web3.js": "^1.73.0", - "@wormhole-foundation/sdk-definitions": "^0.5.0", + "@wormhole-foundation/sdk-definitions": "^0.5.2-beta.0", "@xlabs-libs/wallet-aggregator-aptos": "^0.0.1-alpha.14", "@xlabs-libs/wallet-aggregator-core": "^0.0.1-alpha.18", "@xlabs-libs/wallet-aggregator-cosmos": "^0.0.1-alpha.14", diff --git a/wormhole-connect/src/routes/ntt/payloads/common.ts b/wormhole-connect/src/routes/ntt/payloads/common.ts deleted file mode 100644 index 4d5a5ace1..000000000 --- a/wormhole-connect/src/routes/ntt/payloads/common.ts +++ /dev/null @@ -1,120 +0,0 @@ -import { BN } from '@coral-xyz/anchor'; - -export class TransceiverMessage { - static prefix: Buffer; - sourceNttManager: Buffer; - recipientNttManager: Buffer; - nttManagerPayload: NttManagerMessage; - transceiverPayload: Buffer; - - constructor( - sourceNttManager: Buffer, - recipientNttManager: Buffer, - nttManagerPayload: NttManagerMessage, - transceiverPayload: Buffer, - ) { - this.sourceNttManager = sourceNttManager; - this.recipientNttManager = recipientNttManager; - this.nttManagerPayload = nttManagerPayload; - this.transceiverPayload = transceiverPayload; - } - - static deserialize( - data: Buffer, - deserializer: (data: Buffer) => NttManagerMessage, - ): TransceiverMessage { - if (this.prefix === undefined) { - throw new Error('Unknown prefix.'); - } - const prefix = data.subarray(0, 4); - if (!prefix.equals(this.prefix)) { - throw new Error('Invalid prefix'); - } - const sourceNttManager = data.subarray(4, 36); - const recipientNttManager = data.subarray(36, 68); - const nttManagerPayloadLen = data.readUInt16BE(68); - const nttManagerPayload = deserializer( - data.subarray(70, 70 + nttManagerPayloadLen), - ); - const transceiverPayloadLen = data.readUInt16BE(70 + nttManagerPayloadLen); - const transceiverPayload = data.subarray( - 72 + nttManagerPayloadLen, - 72 + nttManagerPayloadLen + transceiverPayloadLen, - ); - return new TransceiverMessage( - sourceNttManager, - recipientNttManager, - nttManagerPayload, - transceiverPayload, - ); - } - - static serialize( - msg: TransceiverMessage, - serializer: (payload: NttManagerMessage) => Buffer, - ): Buffer { - const payload = serializer(msg.nttManagerPayload); - if (msg.sourceNttManager.length !== 32) { - throw new Error('sourceNttManager must be 32 bytes'); - } - if (msg.recipientNttManager.length !== 32) { - throw new Error('recipientNttManager must be 32 bytes'); - } - const payloadLen = new BN(payload.length).toBuffer('be', 2); - const transceiverPayloadLen = new BN( - msg.transceiverPayload.length, - ).toBuffer('be', 2); - const buffer = Buffer.concat([ - this.prefix, - msg.sourceNttManager, - msg.recipientNttManager, - payloadLen, - payload, - transceiverPayloadLen, - msg.transceiverPayload, - ]); - return buffer; - } -} - -export class NttManagerMessage { - id: Buffer; - sender: Buffer; - payload: A; - - constructor(id: Buffer, sender: Buffer, payload: A) { - if (id.length !== 32) { - throw new Error('id must be 32 bytes'); - } - if (sender.length !== 32) { - throw new Error('sender must be 32 bytes'); - } - this.id = id; - this.sender = sender; - this.payload = payload; - } - - static deserialize = ( - data: Buffer, - deserializer: (data: Buffer) => A, - ): NttManagerMessage => { - const id = data.subarray(0, 32); - const sender = data.subarray(32, 64); - const payloadLen = data.readUint16BE(64); - const payload = deserializer(data.subarray(66, 66 + payloadLen)); - return new NttManagerMessage(id, sender, payload); - }; - - static serialize = ( - msg: NttManagerMessage, - serializer: (payload: A) => Buffer, - ): Buffer => { - const payload = serializer(msg.payload); - return Buffer.concat([ - msg.id, - msg.sender, - new BN(payload.length).toBuffer('be', 2), - payload, - ]); - }; -} diff --git a/wormhole-connect/src/routes/ntt/payloads/transfers.ts b/wormhole-connect/src/routes/ntt/payloads/transfers.ts deleted file mode 100644 index 94cc6e63b..000000000 --- a/wormhole-connect/src/routes/ntt/payloads/transfers.ts +++ /dev/null @@ -1,50 +0,0 @@ -import { TrimmedAmount } from './trimmedAmount'; - -export class NativeTokenTransfer { - static prefix = Buffer.from([0x99, 0x4e, 0x54, 0x54]); - trimmedAmount: TrimmedAmount; - sourceToken: Buffer; - recipientAddress: Buffer; - recipientChain: number; - - constructor( - sourceToken: Buffer, - amount: TrimmedAmount, - recipientChain: number, - recipientAddress: Buffer, - ) { - this.trimmedAmount = amount; - this.sourceToken = sourceToken; - this.recipientAddress = recipientAddress; - this.recipientChain = recipientChain; - } - - static deserialize = (data: Buffer): NativeTokenTransfer => { - const prefix = data.subarray(0, 4); - if (!prefix.equals(NativeTokenTransfer.prefix)) { - throw new Error('Invalid prefix'); - } - const amount = TrimmedAmount.deserialize(data.subarray(4, 13)); - const sourceToken = data.subarray(13, 45); - const recipientAddress = data.subarray(45, 77); - const recipientChain = data.readUInt16BE(77); - return new NativeTokenTransfer( - sourceToken, - amount, - recipientChain, - recipientAddress, - ); - }; - - static serialize = (msg: NativeTokenTransfer): Buffer => { - const buffer = Buffer.concat([ - NativeTokenTransfer.prefix, - TrimmedAmount.serialize(msg.trimmedAmount), - msg.sourceToken, - msg.recipientAddress, - ]); - const recipientChain = Buffer.alloc(2); - recipientChain.writeUInt16BE(msg.recipientChain, 0); - return Buffer.concat([buffer, recipientChain]); - }; -} diff --git a/wormhole-connect/src/routes/ntt/payloads/trimmedAmount.ts b/wormhole-connect/src/routes/ntt/payloads/trimmedAmount.ts deleted file mode 100644 index b44904198..000000000 --- a/wormhole-connect/src/routes/ntt/payloads/trimmedAmount.ts +++ /dev/null @@ -1,22 +0,0 @@ -export class TrimmedAmount { - amount: bigint; - decimals: number; - - constructor(amount: bigint, decimals: number) { - this.amount = amount; - this.decimals = decimals; - } - - static deserialize(data: Buffer): TrimmedAmount { - const decimals = data.readUInt8(0); - const amount = data.readBigUInt64BE(1); - return new TrimmedAmount(amount, decimals); - } - - static serialize(amount: TrimmedAmount): Buffer { - const buffer = Buffer.alloc(9); - buffer.writeUInt8(amount.decimals, 0); - buffer.writeBigUInt64BE(amount.amount, 1); - return buffer; - } -} diff --git a/wormhole-connect/src/routes/ntt/payloads/wormhole.ts b/wormhole-connect/src/routes/ntt/payloads/wormhole.ts deleted file mode 100644 index b1ee02c71..000000000 --- a/wormhole-connect/src/routes/ntt/payloads/wormhole.ts +++ /dev/null @@ -1,5 +0,0 @@ -import { TransceiverMessage } from './common'; - -export class WormholeTransceiverMessage extends TransceiverMessage { - static prefix = Buffer.from([0x99, 0x45, 0xff, 0x10]); -} diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts b/wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts index e921c1150..60980d988 100644 --- a/wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts +++ b/wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts @@ -12,12 +12,10 @@ import { getNttToken } from 'store/transferInput'; import { getTokenById, getTokenDecimals } from 'utils'; import { getWormholeLogEvm } from 'utils/vaa'; import { NttManager__factory } from './abis'; -import { - getNttManagerMessageDigest, - parseWormholeTransceiverMessage, -} from 'routes/ntt/utils'; import config from 'config'; -import { toChainId, toChainName } from 'utils/sdk'; +import { toChainName } from 'utils/sdk'; +import { deserializePayload, Ntt } from '@wormhole-foundation/sdk-definitions'; +import { toChain, toChainId } from '@wormhole-foundation/sdk-base'; const RELAYING_INFO_EVENT_TOPIC = '0x375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271'; @@ -74,12 +72,15 @@ export const getMessageEvm = async ( } else { throw new Error(`Unexpected relaying type ${relayingType}`); } - const transceiverMessage = parseWormholeTransceiverMessage(payload); + const transceiverMessage = deserializePayload( + 'Ntt:WormholeTransfer', + payload, + ); const nttManagerMessage = transceiverMessage.nttManagerPayload; - const toChain = toChainName( - nttManagerMessage.payload.recipientChain as ChainId, + const recipientChain = toChainName( + toChainId(nttManagerMessage.payload.recipientChain) as ChainId, ); - const receivedTokenKey = getNttToken(token.ntt.groupId, toChain); + const receivedTokenKey = getNttToken(token.ntt.groupId, recipientChain); if (!receivedTokenKey) { throw new Error(`Received token key not found for ${tokenId}`); } @@ -89,16 +90,16 @@ export const getMessageEvm = async ( amount: nttManagerMessage.payload.trimmedAmount.amount.toString(), payloadID: 0, recipient: config.wh.parseAddress( - nttManagerMessage.payload.recipientAddress, - toChain, + nttManagerMessage.payload.recipientAddress.toString(), + recipientChain, ), - toChain, + toChain: recipientChain, fromChain, tokenAddress, tokenChain: token.nativeChain, tokenId, tokenKey: token.key, - tokenDecimals: getTokenDecimals(toChainId(fromChain), tokenId), + tokenDecimals: getTokenDecimals(config.wh.toChainId(fromChain), tokenId), receivedTokenKey, emitterAddress: hexlify( config.wh.formatAddress(parsedWormholeLog.args.sender, fromChain), @@ -107,10 +108,15 @@ export const getMessageEvm = async ( block: receipt.blockNumber, gasFee: receipt.gasUsed.mul(receipt.effectiveGasPrice).toString(), recipientNttManager: config.wh.parseAddress( - hexlify(transceiverMessage.recipientNttManager), - toChain, + hexlify(transceiverMessage.recipientNttManager.toString()), + recipientChain, + ), + messageDigest: hexlify( + Ntt.messageDigest( + toChain(config.wh.toChainId(fromChain) as number), + nttManagerMessage, + ), ), - messageDigest: getNttManagerMessageDigest(fromChain, nttManagerMessage), relayerFee: deliveryPayment.toString(), relayingType, }; diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts b/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts index 31b651e5d..dfa2031f6 100644 --- a/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts +++ b/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts @@ -4,11 +4,10 @@ import { hexlify } from 'ethers/lib/utils'; import { NttRelayingType, UnsignedNttMessage } from 'routes/types'; import { getNttToken } from 'store/transferInput'; import { getTokenById, getTokenDecimals } from 'utils'; -import { - getNttManagerMessageDigest, - parseWormholeTransceiverMessage, -} from 'routes/ntt/utils'; import config from 'config'; +import { deserializePayload, Ntt } from '@wormhole-foundation/sdk-definitions'; +import { toChainId } from '@wormhole-foundation/sdk-base'; +import { ChainName } from '@wormhole-foundation/wormhole-connect-sdk'; export const getMessageSolana = async ( tx: string, @@ -20,7 +19,8 @@ export const getMessageSolana = async ( maxSupportedTransactionVersion: 0, }); if (!response) throw new Error('Transaction not found'); - const core = config.wh.mustGetContracts('solana').core; + const fromChain: ChainName = 'solana'; + const core = config.wh.mustGetContracts(fromChain).core; const accounts = response.transaction.message.getAccountKeys(); const wormholeIx = response.meta?.innerInstructions ?.flatMap((ix) => ix.instructions) @@ -37,16 +37,16 @@ export const getMessageSolana = async ( const messageData = PostedMessageData.deserialize( wormholeMessageAccount.data, ); - const transceiverMessage = parseWormholeTransceiverMessage( + const transceiverMessage = deserializePayload( + 'Ntt:WormholeTransfer', messageData.message.payload, ); const nttManagerMessage = transceiverMessage.nttManagerPayload; - const fromChain = config.wh.toChainName('solana'); - const toChain = config.wh.toChainName( - nttManagerMessage.payload.recipientChain, + const recipientChain = config.wh.toChainName( + toChainId(nttManagerMessage.payload.recipientChain), ); const tokenAddress = config.wh.parseAddress( - hexlify(nttManagerMessage.payload.sourceToken), + hexlify(nttManagerMessage.payload.sourceToken.toString()), fromChain, ); const tokenId = { @@ -57,7 +57,7 @@ export const getMessageSolana = async ( if (!token?.ntt) { throw new Error(`Token ${tokenId} not found`); } - const receivedTokenKey = getNttToken(token.ntt.groupId, toChain); + const receivedTokenKey = getNttToken(token.ntt.groupId, recipientChain); if (!receivedTokenKey) { throw new Error(`Received token key not found for ${tokenId}`); } @@ -68,19 +68,19 @@ export const getMessageSolana = async ( return { sendTx: tx, sender: config.wh.parseAddress( - hexlify(nttManagerMessage.sender), + hexlify(nttManagerMessage.sender.toUint8Array()), fromChain, ), amount: nttManagerMessage.payload.trimmedAmount.amount.toString(), payloadID: 0, recipient: config.wh.parseAddress( - hexlify(nttManagerMessage.payload.recipientAddress), - toChain, + hexlify(nttManagerMessage.payload.recipientAddress.toString()), + recipientChain, ), - toChain, + toChain: recipientChain, fromChain, tokenAddress: config.wh.parseAddress( - hexlify(nttManagerMessage.payload.sourceToken), + hexlify(nttManagerMessage.payload.sourceToken.toString()), fromChain, ), tokenChain: token.nativeChain, @@ -95,10 +95,11 @@ export const getMessageSolana = async ( block: response.slot, gasFee: response.meta?.fee.toString(), recipientNttManager: config.wh.parseAddress( - hexlify(transceiverMessage.recipientNttManager), - toChain, + hexlify(transceiverMessage.recipientNttManager.toString()), + recipientChain, ), - messageDigest: getNttManagerMessageDigest(fromChain, nttManagerMessage), + // messageDigest: getNttManagerMessageDigest(fromChain, nttManagerMessage), + messageDigest: hexlify(Ntt.messageDigest('Solana', nttManagerMessage)), relayerFee: relayerFee || '', relayingType: relayerFee ? NttRelayingType.Special : NttRelayingType.Manual, }; diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts b/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts index 6bea6dc51..28a5af876 100644 --- a/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts +++ b/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts @@ -22,10 +22,7 @@ import { import { BN, IdlAccounts, Program } from '@coral-xyz/anchor'; import { SignedVaa, parseVaa } from '@certusone/wormhole-sdk/lib/esm'; import { utils } from 'ethers'; -import { - getNttManagerMessageDigest, - parseWormholeTransceiverMessage, -} from 'routes/ntt/utils'; +import { deserializePayload, Ntt } from '@wormhole-foundation/sdk-definitions'; import { ExampleNativeTokenTransfers, IDL, @@ -39,6 +36,8 @@ import { NttQuoter } from './nttQuoter'; import { getTokenById } from 'utils'; import { Keccak } from 'sha3'; import CONFIG from 'config'; +import { toChain as SDKv2toChain } from '@wormhole-foundation/sdk-base'; +import { hexlify } from 'ethers/lib/utils'; // TODO: make sure this is in sync with the contract const RATE_LIMIT_DURATION = 24 * 60 * 60; @@ -197,16 +196,17 @@ export class NttManagerSolana { // just make the second instruction a no-op in case the transfer is delayed. tx.add(await this.createReceiveWormholeMessageInstruction(redeemArgs)); tx.add(await this.createRedeemInstruction(redeemArgs)); - const { nttManagerPayload } = parseWormholeTransceiverMessage( + const { nttManagerPayload } = deserializePayload( + 'Ntt:WormholeTransfer', parsedVaa.payload, ); - const messageDigest = getNttManagerMessageDigest( - chainId, + const messageDigest = Ntt.messageDigest( + SDKv2toChain(chainId), nttManagerPayload, ); const releaseArgs = { ...redeemArgs, - messageDigest, + messageDigest: hexlify(messageDigest), recipient: new PublicKey(nttManagerPayload.payload.recipientAddress), chain: chainId, revertOnDelay: false, @@ -662,7 +662,8 @@ export class NttManagerSolana { config?: Config; }): Promise { const parsedVaa = parseVaa(args.vaa); - const { nttManagerPayload } = parseWormholeTransceiverMessage( + const { nttManagerPayload } = deserializePayload( + 'Ntt:WormholeTransfer', parsedVaa.payload, ); const chainId = toChainId(parsedVaa.emitterChain as ChainId); @@ -676,7 +677,7 @@ export class NttManagerSolana { vaa: derivePostedVaaKey(this.wormholeId, parseVaa(args.vaa).hash), transceiverMessage: this.transceiverMessageAccountAddress( chainId, - nttManagerPayload.id, + Buffer.from(nttManagerPayload.id), ), }) .instruction(); @@ -689,12 +690,13 @@ export class NttManagerSolana { }): Promise { const config = await this.getConfig(args.config); const parsedVaa = parseVaa(args.vaa); - const { nttManagerPayload } = parseWormholeTransceiverMessage( + const { nttManagerPayload } = deserializePayload( + 'Ntt:WormholeTransfer', parsedVaa.payload, ); const chainId = toChainId(parsedVaa.emitterChain as ChainId); - const messageDigest = getNttManagerMessageDigest( - chainId, + const messageDigest = Ntt.messageDigest( + SDKv2toChain(chainId), nttManagerPayload, ); const nttManagerPeer = this.peerAccountAddress(chainId); @@ -707,11 +709,11 @@ export class NttManagerSolana { peer: nttManagerPeer, transceiverMessage: this.transceiverMessageAccountAddress( chainId, - nttManagerPayload.id, + Buffer.from(nttManagerPayload.id), ), transceiver: this.registeredTransceiverAddress(this.program.programId), mint: await this.mintAccountAddress(config), - inboxItem: this.inboxItemAccountAddress(messageDigest), + inboxItem: this.inboxItemAccountAddress(hexlify(messageDigest)), inboxRateLimit, outboxRateLimit: this.outboxRateLimitAccountAddress(), }) diff --git a/wormhole-connect/src/routes/ntt/utils.ts b/wormhole-connect/src/routes/ntt/utils.ts index 70bdf6f0b..676a75b24 100644 --- a/wormhole-connect/src/routes/ntt/utils.ts +++ b/wormhole-connect/src/routes/ntt/utils.ts @@ -1,35 +1,3 @@ -import { ChainId, ChainName } from '@wormhole-foundation/wormhole-connect-sdk'; -import { keccak256 } from 'ethers/lib/utils'; -import { NttManagerMessage } from './payloads/common'; -import { NativeTokenTransfer } from './payloads/transfers'; -import { WormholeTransceiverMessage } from './payloads/wormhole'; -import config from 'config'; - -export const getNttManagerMessageDigest = ( - emitterChain: ChainName | ChainId, - message: NttManagerMessage, -): string => { - const chainIdBuffer = Buffer.alloc(2); - chainIdBuffer.writeUInt16BE(config.wh.toChainId(emitterChain)); - const serialized = NttManagerMessage.serialize( - message, - NativeTokenTransfer.serialize, - ); - const digest = keccak256(Buffer.concat([chainIdBuffer, serialized])); - return digest; -}; - -export const parseWormholeTransceiverMessage = ( - message: string | Buffer, -): WormholeTransceiverMessage => { - const buffer = Buffer.isBuffer(message) - ? message - : Buffer.from(message.slice(2), 'hex'); - return WormholeTransceiverMessage.deserialize(buffer, (a) => - NttManagerMessage.deserialize(a, NativeTokenTransfer.deserialize), - ); -}; - export interface WormholeTransceiverInstruction { shouldSkipRelayerSend: boolean; } From cfac4ab6becccd8f07f980c8001f048984dc9f1d Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Wed, 27 Mar 2024 14:17:40 -0500 Subject: [PATCH 03/17] renamed platforms -> chains --- .../ntt/{platforms => chains}/evm/abis/NttManager.ts | 0 .../{platforms => chains}/evm/abis/NttManager__factory.ts | 0 .../{platforms => chains}/evm/abis/WormholeTransceiver.ts | 0 .../evm/abis/WormholeTransceiver__factory.ts | 0 .../routes/ntt/{platforms => chains}/evm/abis/common.ts | 0 .../routes/ntt/{platforms => chains}/evm/abis/index.ts | 0 .../routes/ntt/{platforms => chains}/evm/getMessage.ts | 0 .../src/routes/ntt/{platforms => chains}/evm/index.ts | 0 .../routes/ntt/{platforms => chains}/evm/nttManager.ts | 0 .../ntt/{platforms => chains}/evm/wormholeTransceiver.ts | 0 .../src/routes/ntt/{platforms => chains}/index.ts | 0 .../routes/ntt/{platforms => chains}/solana/getMessage.ts | 1 - .../src/routes/ntt/{platforms => chains}/solana/index.ts | 0 .../routes/ntt/{platforms => chains}/solana/nttManager.ts | 2 +- .../routes/ntt/{platforms => chains}/solana/nttQuoter.ts | 8 ++++++++ .../solana/types/example_native_token_transfers.ts | 0 .../ntt/{platforms => chains}/solana/types/ntt_quoter.ts | 0 wormhole-connect/src/routes/ntt/nttBase.ts | 8 +++++--- wormhole-connect/src/routes/ntt/nttRelay.ts | 6 +++--- wormhole-connect/src/routes/operator.ts | 8 ++++---- 20 files changed, 21 insertions(+), 12 deletions(-) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/abis/NttManager.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/abis/NttManager__factory.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/abis/WormholeTransceiver.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/abis/WormholeTransceiver__factory.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/abis/common.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/abis/index.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/getMessage.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/index.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/nttManager.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/evm/wormholeTransceiver.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/index.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/solana/getMessage.ts (98%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/solana/index.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/solana/nttManager.ts (99%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/solana/nttQuoter.ts (94%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/solana/types/example_native_token_transfers.ts (100%) rename wormhole-connect/src/routes/ntt/{platforms => chains}/solana/types/ntt_quoter.ts (100%) diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager__factory.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/abis/NttManager__factory.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager__factory.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver__factory.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/abis/WormholeTransceiver__factory.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver__factory.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/common.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/common.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/abis/common.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/common.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/abis/index.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/index.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/abis/index.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/index.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts b/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/getMessage.ts rename to wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/index.ts b/wormhole-connect/src/routes/ntt/chains/evm/index.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/index.ts rename to wormhole-connect/src/routes/ntt/chains/evm/index.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/nttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/nttManager.ts rename to wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/evm/wormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/evm/wormholeTransceiver.ts rename to wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/index.ts b/wormhole-connect/src/routes/ntt/chains/index.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/index.ts rename to wormhole-connect/src/routes/ntt/chains/index.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts b/wormhole-connect/src/routes/ntt/chains/solana/getMessage.ts similarity index 98% rename from wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts rename to wormhole-connect/src/routes/ntt/chains/solana/getMessage.ts index dfa2031f6..a8df48b30 100644 --- a/wormhole-connect/src/routes/ntt/platforms/solana/getMessage.ts +++ b/wormhole-connect/src/routes/ntt/chains/solana/getMessage.ts @@ -98,7 +98,6 @@ export const getMessageSolana = async ( hexlify(transceiverMessage.recipientNttManager.toString()), recipientChain, ), - // messageDigest: getNttManagerMessageDigest(fromChain, nttManagerMessage), messageDigest: hexlify(Ntt.messageDigest('Solana', nttManagerMessage)), relayerFee: relayerFee || '', relayingType: relayerFee ? NttRelayingType.Special : NttRelayingType.Manual, diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/index.ts b/wormhole-connect/src/routes/ntt/chains/solana/index.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/solana/index.ts rename to wormhole-connect/src/routes/ntt/chains/solana/index.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts b/wormhole-connect/src/routes/ntt/chains/solana/nttManager.ts similarity index 99% rename from wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts rename to wormhole-connect/src/routes/ntt/chains/solana/nttManager.ts index 28a5af876..a28bcfad3 100644 --- a/wormhole-connect/src/routes/ntt/platforms/solana/nttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/solana/nttManager.ts @@ -31,7 +31,7 @@ import { derivePostedVaaKey, getWormholeDerivedAccounts, } from '@certusone/wormhole-sdk/lib/esm/solana/wormhole'; -import { associatedAddress } from '@coral-xyz/anchor/dist/cjs/utils/token'; +import { associatedAddress } from '@coral-xyz/anchor/dist/esm/utils/token'; import { NttQuoter } from './nttQuoter'; import { getTokenById } from 'utils'; import { Keccak } from 'sha3'; diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/nttQuoter.ts b/wormhole-connect/src/routes/ntt/chains/solana/nttQuoter.ts similarity index 94% rename from wormhole-connect/src/routes/ntt/platforms/solana/nttQuoter.ts rename to wormhole-connect/src/routes/ntt/chains/solana/nttQuoter.ts index d7ea901ba..250117ee9 100644 --- a/wormhole-connect/src/routes/ntt/platforms/solana/nttQuoter.ts +++ b/wormhole-connect/src/routes/ntt/chains/solana/nttQuoter.ts @@ -60,6 +60,7 @@ export class NttQuoter { } } + // TODO: will change with https://github.dev/wormhole-foundation/example-native-token-transfers/pull/319 async calcRelayCost(chain: ChainName | ChainId) { const [chainData, instanceData, rentCost] = await Promise.all([ this.getRegisteredChain(chain), @@ -69,6 +70,13 @@ export class NttQuoter { ), ]); + if (chainData.nativePriceUsd === 0) { + throw new Error('Native price is 0'); + } + if (instanceData.solPriceUsd === 0) { + throw new Error('SOL price is 0'); + } + const totalNativeGasCostUsd = chainData.nativePriceUsd * ((chainData.gasPriceGwei * EVM_GAS_COST) / GWEI_PER_ETH); diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/types/example_native_token_transfers.ts b/wormhole-connect/src/routes/ntt/chains/solana/types/example_native_token_transfers.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/solana/types/example_native_token_transfers.ts rename to wormhole-connect/src/routes/ntt/chains/solana/types/example_native_token_transfers.ts diff --git a/wormhole-connect/src/routes/ntt/platforms/solana/types/ntt_quoter.ts b/wormhole-connect/src/routes/ntt/chains/solana/types/ntt_quoter.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/platforms/solana/types/ntt_quoter.ts rename to wormhole-connect/src/routes/ntt/chains/solana/types/ntt_quoter.ts diff --git a/wormhole-connect/src/routes/ntt/nttBase.ts b/wormhole-connect/src/routes/ntt/nttBase.ts index e092f7a4d..6413ef69e 100644 --- a/wormhole-connect/src/routes/ntt/nttBase.ts +++ b/wormhole-connect/src/routes/ntt/nttBase.ts @@ -29,14 +29,14 @@ import { toNormalizedDecimals, } from 'utils'; import { getNttToken } from 'store/transferInput'; -import { getNttManager } from './platforms'; +import { getNttManager } from './chains'; import { InboundQueuedTransfer } from './types'; import { ContractIsPausedError, DestinationContractIsPausedError, } from './errors'; -import { WormholeTransceiver, getMessageEvm } from './platforms/evm'; -import { NttManagerSolana, getMessageSolana } from './platforms/solana'; +import { WormholeTransceiver, getMessageEvm } from './chains/evm'; +import { NttManagerSolana, getMessageSolana } from './chains/solana'; import { formatGasFee } from 'routes/utils'; import { NO_INPUT } from 'utils/style'; import { estimateAverageGasFee } from 'utils/gas'; @@ -102,6 +102,7 @@ export abstract class NttBase extends BaseRoute { sourceChain: ChainName | ChainId, destChain: ChainName | ChainId, ): Promise { + console.log('isRouteSupported'); return await Promise.all([ this.isSupportedChain(toChainName(sourceChain)), this.isSupportedChain(toChainName(destChain)), @@ -229,6 +230,7 @@ export abstract class NttBase extends BaseRoute { throw new Error('Amount too low'); } const shouldSkipRelayerSend = this.TYPE !== Route.NttRelay; + // TODO: will change with https://github.com/wormhole-foundation/example-native-token-transfers/pull/326 refund address return await nttManager.send( token, senderAddress, diff --git a/wormhole-connect/src/routes/ntt/nttRelay.ts b/wormhole-connect/src/routes/ntt/nttRelay.ts index e559da66a..c40a7fba3 100644 --- a/wormhole-connect/src/routes/ntt/nttRelay.ts +++ b/wormhole-connect/src/routes/ntt/nttRelay.ts @@ -1,6 +1,6 @@ import { Route, TokenConfig } from 'config/types'; import { BigNumber } from 'ethers'; -import { getNttManager } from './platforms'; +import { getNttManager } from './chains'; import { ChainName, ChainId } from '@wormhole-foundation/wormhole-connect-sdk'; import { NttBase } from './nttBase'; import { @@ -26,8 +26,8 @@ import { import { NO_INPUT } from 'utils/style'; import { TokenPrices } from 'store/tokenPrices'; import { toDecimals, toFixedDecimals } from 'utils/balance'; -import { NttManagerEvm, WormholeTransceiver } from './platforms/evm'; -import { NttQuoter } from './platforms/solana/nttQuoter'; +import { NttManagerEvm, WormholeTransceiver } from './chains/evm'; +import { NttQuoter } from './chains/solana/nttQuoter'; import config from 'config'; export class NttRelay extends NttBase { diff --git a/wormhole-connect/src/routes/operator.ts b/wormhole-connect/src/routes/operator.ts index b28cf55f7..a414503f1 100644 --- a/wormhole-connect/src/routes/operator.ts +++ b/wormhole-connect/src/routes/operator.ts @@ -37,8 +37,8 @@ import { ETHBridge } from './porticoBridge/ethBridge'; import { wstETHBridge } from './porticoBridge/wstETHBridge'; import { TokenPrices } from 'store/tokenPrices'; import { NttManual, NttRelay } from './ntt'; -import { getMessageEvm as getNttMessageEvm } from './ntt/platforms/evm'; -import { getMessageSolana as getNttMessageSolana } from './ntt/platforms/solana'; +import { getMessageEvm } from './ntt/chains/evm'; +import { getMessageSolana } from './ntt/chains/solana'; export class Operator { getRoute(route: Route): RouteAbstract { @@ -112,7 +112,7 @@ export class Operator { if ( config.tokensArr.some(({ ntt }) => ntt && ntt.nttManager === receipt.to) ) { - const { relayingType } = await getNttMessageEvm(txHash, chain, receipt); + const { relayingType } = await getMessageEvm(txHash, chain, receipt); return relayingType === NttRelayingType.Manual ? Route.NttManual : Route.NttRelay; @@ -132,7 +132,7 @@ export class Operator { ), ) ) { - const { relayingType } = await getNttMessageSolana(txHash); + const { relayingType } = await getMessageSolana(txHash); return relayingType === NttRelayingType.Manual ? Route.NttManual : Route.NttRelay; From 5b0de56b67d20fdea496345a46b40dec9df97404 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Wed, 27 Mar 2024 15:08:26 -0500 Subject: [PATCH 04/17] added sepolia cctp, removed goerli cctp --- sdk/src/config/TESTNET.ts | 25 +++++-------------------- 1 file changed, 5 insertions(+), 20 deletions(-) diff --git a/sdk/src/config/TESTNET.ts b/sdk/src/config/TESTNET.ts index 7a431b594..cea6b122c 100644 --- a/sdk/src/config/TESTNET.ts +++ b/sdk/src/config/TESTNET.ts @@ -6,7 +6,6 @@ import { WormholeConfig, Context, ChainConfig, Contracts } from '../types'; */ export const TESTNET_CHAINS = { solana: 1, - goerli: 2, bsc: 4, mumbai: 5, fuji: 6, @@ -48,24 +47,6 @@ export type ChainContracts = { }; const TESTNET: { [chain in TestnetChainName]: ChainConfig } = { - goerli: { - key: 'goerli', - id: 2, - context: Context.ETH, - contracts: { - ...CONTRACTS.TESTNET.ethereum, - relayer: '0x9563a59c15842a6f322b10f69d1dd88b41f2e97b', - cctpContracts: { - cctpTokenMessenger: '0xd0c3da58f55358142b8d3e06c1c30c5c6114efe8', - cctpMessageTransmitter: '0x26413e8157cd32011e726065a5462e97dd4d03d9', - wormholeCircleRelayer: '0x17da1ff5386d044c63f00747b5b8ad1e3806448d', - wormholeCCTP: '0x0a69146716b3a21622287efa1607424c663069a4', - }, - }, - finalityThreshold: 64, - nativeTokenDecimals: 18, - cctpDomain: 0, - }, solana: { key: 'solana', id: 1, @@ -323,9 +304,14 @@ const TESTNET: { [chain in TestnetChainName]: ChainConfig } = { context: Context.ETH, contracts: { ...CONTRACTS.TESTNET.sepolia, + cctpContracts: { + cctpTokenMessenger: '0x9f3b8679c73c2fef8b59b4f3444d4e156fb70aa5', + cctpMessageTransmitter: '0x7865fafc2db2093669d92c0f33aeef291086befd', + }, }, finalityThreshold: 0, nativeTokenDecimals: 18, + cctpDomain: 0, }, arbitrum_sepolia: { key: 'arbitrum_sepolia', @@ -374,7 +360,6 @@ const env: Environment = 'TESTNET'; const TESTNET_CONFIG: WormholeConfig = { env, rpcs: { - goerli: 'https://rpc.ankr.com/eth_goerli', mumbai: 'https://rpc.ankr.com/polygon_mumbai', bsc: 'https://data-seed-prebsc-1-s3.binance.org:8545', fuji: 'https://api.avax-test.network/ext/bc/C/rpc', From 384a793d3d471d9952379b7a88202dbe557ee90a Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Thu, 28 Mar 2024 14:12:19 -0500 Subject: [PATCH 05/17] reworked ntt config, added ntt groups --- sdk/src/config/TESTNET.ts | 14 ++ wormhole-connect/src/config/devnet/index.ts | 2 + .../src/config/devnet/nttGroups.ts | 3 + wormhole-connect/src/config/index.ts | 4 + wormhole-connect/src/config/mainnet/index.ts | 2 + .../src/config/mainnet/nttGroups.ts | 3 + .../src/config/testnet/gasEstimates.ts | 4 + wormhole-connect/src/config/testnet/index.ts | 2 + .../src/config/testnet/nttGroups.ts | 90 +++++++++++++ wormhole-connect/src/config/testnet/tokens.ts | 59 +++++---- wormhole-connect/src/config/types.ts | 29 +++- .../src/routes/abstracts/routeAbstract.ts | 1 + .../src/routes/bridge/baseRoute.ts | 4 - wormhole-connect/src/routes/bridge/bridge.ts | 5 +- .../src/routes/cctpManual/cctpManual.ts | 1 + .../src/routes/cctpManual/utils/chains.ts | 6 +- .../src/routes/cosmosGateway/cosmosGateway.ts | 1 + .../src/routes/hashflow/hashflow.ts | 1 + .../src/routes/ntt/chains/evm/getMessage.ts | 32 +++-- .../src/routes/ntt/chains/evm/nttManager.ts | 15 ++- .../routes/ntt/chains/solana/getMessage.ts | 33 +++-- .../routes/ntt/chains/solana/nttManager.ts | 17 ++- wormhole-connect/src/routes/ntt/nttBase.ts | 97 +++++++------- wormhole-connect/src/routes/ntt/nttRelay.ts | 45 +++++-- wormhole-connect/src/routes/operator.ts | 10 +- .../src/routes/porticoBridge/porticoBridge.ts | 1 + wormhole-connect/src/routes/tbtc/tbtc.ts | 1 + wormhole-connect/src/routes/utils.ts | 10 ++ wormhole-connect/src/store/transferInput.ts | 43 +++--- wormhole-connect/src/utils/ntt.ts | 124 ++++++++++++++++++ .../src/views/Bridge/Inputs/TokenWarnings.tsx | 3 +- .../Bridge/NttInboundCapacityWarning.tsx | 23 ++-- 32 files changed, 510 insertions(+), 175 deletions(-) create mode 100644 wormhole-connect/src/config/devnet/nttGroups.ts create mode 100644 wormhole-connect/src/config/mainnet/nttGroups.ts create mode 100644 wormhole-connect/src/config/testnet/nttGroups.ts create mode 100644 wormhole-connect/src/utils/ntt.ts diff --git a/sdk/src/config/TESTNET.ts b/sdk/src/config/TESTNET.ts index cea6b122c..5112a2a3b 100644 --- a/sdk/src/config/TESTNET.ts +++ b/sdk/src/config/TESTNET.ts @@ -6,6 +6,7 @@ import { WormholeConfig, Context, ChainConfig, Contracts } from '../types'; */ export const TESTNET_CHAINS = { solana: 1, + goerli: 2, bsc: 4, mumbai: 5, fuji: 6, @@ -47,6 +48,18 @@ export type ChainContracts = { }; const TESTNET: { [chain in TestnetChainName]: ChainConfig } = { + goerli: { + key: 'goerli', + id: 2, + context: Context.ETH, + contracts: { + ...CONTRACTS.TESTNET.ethereum, + relayer: '0x9563a59c15842a6f322b10f69d1dd88b41f2e97b', + }, + finalityThreshold: 64, + nativeTokenDecimals: 18, + cctpDomain: 0, + }, solana: { key: 'solana', id: 1, @@ -360,6 +373,7 @@ const env: Environment = 'TESTNET'; const TESTNET_CONFIG: WormholeConfig = { env, rpcs: { + goerli: 'https://rpc.ankr.com/eth_goerli', mumbai: 'https://rpc.ankr.com/polygon_mumbai', bsc: 'https://data-seed-prebsc-1-s3.binance.org:8545', fuji: 'https://api.avax-test.network/ext/bc/C/rpc', diff --git a/wormhole-connect/src/config/devnet/index.ts b/wormhole-connect/src/config/devnet/index.ts index 027b1d712..34b5353d6 100644 --- a/wormhole-connect/src/config/devnet/index.ts +++ b/wormhole-connect/src/config/devnet/index.ts @@ -7,6 +7,7 @@ import { DEVNET_RPC_MAPPING, } from './rpcs'; import { DEVNET_TOKENS } from './tokens'; +import { DEVNET_NTT_GROUPS } from './nttGroups'; export * from './chains'; export * from './gasEstimates'; @@ -20,6 +21,7 @@ const DEVNET: NetworkData = { rpcs: DEVNET_RPC_MAPPING, rest: DEVNET_REST_MAPPING, graphql: DEVNET_GRAPHQL_MAPPING, + nttGroups: DEVNET_NTT_GROUPS, }; export default DEVNET; diff --git a/wormhole-connect/src/config/devnet/nttGroups.ts b/wormhole-connect/src/config/devnet/nttGroups.ts new file mode 100644 index 000000000..e3f03f625 --- /dev/null +++ b/wormhole-connect/src/config/devnet/nttGroups.ts @@ -0,0 +1,3 @@ +import { NttGroups } from 'config/types'; + +export const DEVNET_NTT_GROUPS: NttGroups = {}; diff --git a/wormhole-connect/src/config/index.ts b/wormhole-connect/src/config/index.ts index 35fd91d26..07f3840b7 100644 --- a/wormhole-connect/src/config/index.ts +++ b/wormhole-connect/src/config/index.ts @@ -132,6 +132,10 @@ export function buildConfig( // Route options ethBridgeMaxAmount: customConfig?.ethBridgeMaxAmount ?? 5, wstETHBridgeMaxAmount: customConfig?.wstETHBridgeMaxAmount ?? 5, + + // NTT config + // TODO: allow custom NTT config. validate similar to custom tokens + nttGroups: networkData.nttGroups, }; } diff --git a/wormhole-connect/src/config/mainnet/index.ts b/wormhole-connect/src/config/mainnet/index.ts index 034279826..075d559da 100644 --- a/wormhole-connect/src/config/mainnet/index.ts +++ b/wormhole-connect/src/config/mainnet/index.ts @@ -7,6 +7,7 @@ import { MAINNET_RPC_MAPPING, } from './rpcs'; import { MAINNET_TOKENS } from './tokens'; +import { MAINNET_NTT_GROUPS } from './nttGroups'; export * from './chains'; export * from './gasEstimates'; @@ -20,6 +21,7 @@ const MAINNET: NetworkData = { rpcs: MAINNET_RPC_MAPPING, rest: MAINNET_REST_MAPPING, graphql: MAINNET_GRAPHQL_MAPPING, + nttGroups: MAINNET_NTT_GROUPS, }; export default MAINNET; diff --git a/wormhole-connect/src/config/mainnet/nttGroups.ts b/wormhole-connect/src/config/mainnet/nttGroups.ts new file mode 100644 index 000000000..3f02588ed --- /dev/null +++ b/wormhole-connect/src/config/mainnet/nttGroups.ts @@ -0,0 +1,3 @@ +import { NttGroups } from 'config/types'; + +export const MAINNET_NTT_GROUPS: NttGroups = {}; diff --git a/wormhole-connect/src/config/testnet/gasEstimates.ts b/wormhole-connect/src/config/testnet/gasEstimates.ts index 96bb240a4..cfbe37815 100644 --- a/wormhole-connect/src/config/testnet/gasEstimates.ts +++ b/wormhole-connect/src/config/testnet/gasEstimates.ts @@ -255,6 +255,10 @@ export const TESTNET_GAS_ESTIMATES: GasEstimates = { sendToken: 150000, claim: 200000, }, + [Route.CCTPManual]: { + sendToken: 150000, + claim: 300000, + }, [Route.NttManual]: { sendToken: 200000, claim: 250000, diff --git a/wormhole-connect/src/config/testnet/index.ts b/wormhole-connect/src/config/testnet/index.ts index c4bf27dd3..1e994b1a2 100644 --- a/wormhole-connect/src/config/testnet/index.ts +++ b/wormhole-connect/src/config/testnet/index.ts @@ -7,6 +7,7 @@ import { TESTNET_RPC_MAPPING, } from './rpcs'; import { TESTNET_TOKENS } from './tokens'; +import { TESTNET_NTT_GROUPS } from './nttGroups'; export * from './chains'; export * from './gasEstimates'; @@ -20,6 +21,7 @@ const TESTNET: NetworkData = { rpcs: TESTNET_RPC_MAPPING, rest: TESTNET_REST_MAPPING, graphql: TESTNET_GRAPHQL_MAPPING, + nttGroups: TESTNET_NTT_GROUPS, }; export default TESTNET; diff --git a/wormhole-connect/src/config/testnet/nttGroups.ts b/wormhole-connect/src/config/testnet/nttGroups.ts new file mode 100644 index 000000000..7827fcf2b --- /dev/null +++ b/wormhole-connect/src/config/testnet/nttGroups.ts @@ -0,0 +1,90 @@ +import { NttGroups } from 'config/types'; + +export const TESTNET_NTT_GROUPS: NttGroups = { + TEST_NTT: { + nttManagers: [ + { + chainName: 'sepolia', + address: '0xB231aD95f2301bc82eA44c515001F0F746D637e0', + tokenKey: 'TEST_NTTsepolia', + transceivers: [ + { + address: '0x1fDC902e30b188FD2BA976B421Cb179943F57896', + type: 'wormhole', + }, + ], + }, + { + chainName: 'arbitrum_sepolia', + address: '0xEec94CD3083e067398256a79CcA7e740C5c8ef81', + tokenKey: 'TEST_NTTarbitrum_sepolia', + transceivers: [ + { + address: '0x0E24D17D7467467b39Bf64A9DFf88776Bd6c74d7', + type: 'wormhole', + }, + ], + }, + { + chainName: 'base_sepolia', + address: '0xB03b030b2f5B40819Df76467d67eD1C85Ff66fAD', + tokenKey: 'TEST_NTTbase_sepolia', + transceivers: [ + { + address: '0x1e072169541f1171e427Aa44B5fd8924BEE71b0e', + type: 'wormhole', + }, + ], + }, + { + chainName: 'optimism_sepolia', + address: '0x7f430D4e7939D994C0955A01FC75D9DE33F12D11', + tokenKey: 'TEST_NTToptimism_sepolia', + transceivers: [ + { + address: '0x41265eb2863bf0238081F6AeefeF73549C82C3DD', + type: 'wormhole', + }, + ], + }, + { + chainName: 'solana', + address: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', + tokenKey: 'TEST_NTTsolana', + transceivers: [ + { + address: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', + type: 'wormhole', + }, + ], + solanaQuoter: 'NqTdGLLL6b6bFo7YESNEezocgF8onH5cst5EdH791en', + }, + ], + }, + TEST_USDC: { + nttManagers: [ + { + chainName: 'sepolia', + address: '0xFCD6994bC89FCB5891404Eb6268cFB3701F1C198', + tokenKey: 'USDCsepolia', + transceivers: [ + { + address: '0xE18EF44f81fcF4ba3eD765F0B360B68f823Fac33', + type: 'wormhole', + }, + ], + }, + { + chainName: 'alfajores', + address: '0x12594D5EBF88Deb5b02a6B7d265B421f6EE2CbA6', + tokenKey: 'USDCalfajores', + transceivers: [ + { + address: '0x328f1fa5f84f62177d1e04976FdC49aB07578cf0', + type: 'wormhole', + }, + ], + }, + ], + }, +}; diff --git a/wormhole-connect/src/config/testnet/tokens.ts b/wormhole-connect/src/config/testnet/tokens.ts index 9b6006550..f6a0696fd 100644 --- a/wormhole-connect/src/config/testnet/tokens.ts +++ b/wormhole-connect/src/config/testnet/tokens.ts @@ -900,6 +900,21 @@ export const TESTNET_TOKENS: TokensConfig = { }, }, }, + USDCalfajores: { + key: 'USDCalfajores', + symbol: 'USDC', + nativeChain: 'alfajores', + icon: Icon.USDC, + tokenId: { + chain: 'alfajores', + address: '0x4004d1EB4b65A38c65dc9575bEe3DfCb026Cb538', + }, + coinGeckoId: 'usd-coin', + color: '#2774CA', + decimals: { + default: 6, + }, + }, GLMR: { key: 'GLMR', symbol: 'GLMR', @@ -2124,6 +2139,21 @@ export const TESTNET_TOKENS: TokensConfig = { default: 8, }, }, + USDCsepolia: { + key: 'USDCsepolia', + symbol: 'USDC', + nativeChain: 'sepolia', + icon: Icon.USDC, + tokenId: { + chain: 'sepolia', + address: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', + }, + coinGeckoId: 'usd-coin', + color: '#2774CA', + decimals: { + default: 6, + }, + }, ETHarbitrum_sepolia: { key: 'ETHarbitrum_sepolia', symbol: 'ETH', @@ -2247,11 +2277,6 @@ export const TESTNET_TOKENS: TokensConfig = { Ethereum: 18, default: 8, }, - ntt: { - groupId: 'test_ntt', - nttManager: '0xB231aD95f2301bc82eA44c515001F0F746D637e0', - wormholeTransceiver: '0x1fDC902e30b188FD2BA976B421Cb179943F57896', - }, }, TEST_NTTarbitrum_sepolia: { key: 'TEST_NTTarbitrum_sepolia', @@ -2268,11 +2293,6 @@ export const TESTNET_TOKENS: TokensConfig = { Ethereum: 18, default: 8, }, - ntt: { - groupId: 'test_ntt', - nttManager: '0xEec94CD3083e067398256a79CcA7e740C5c8ef81', - wormholeTransceiver: '0x0E24D17D7467467b39Bf64A9DFf88776Bd6c74d7', - }, }, TEST_NTTbase_sepolia: { key: 'TEST_NTTbase_sepolia', @@ -2289,11 +2309,6 @@ export const TESTNET_TOKENS: TokensConfig = { Ethereum: 18, default: 8, }, - ntt: { - groupId: 'test_ntt', - nttManager: '0xB03b030b2f5B40819Df76467d67eD1C85Ff66fAD', - wormholeTransceiver: '0x1e072169541f1171e427Aa44B5fd8924BEE71b0e', - }, }, TEST_NTToptimism_sepolia: { key: 'TEST_NTToptimism_sepolia', @@ -2310,11 +2325,6 @@ export const TESTNET_TOKENS: TokensConfig = { Ethereum: 18, default: 8, }, - ntt: { - groupId: 'test_ntt', - nttManager: '0x7f430D4e7939D994C0955A01FC75D9DE33F12D11', - wormholeTransceiver: '0x41265eb2863bf0238081F6AeefeF73549C82C3DD', - }, }, TEST_NTTsolana: { key: 'TEST_NTTsolana', @@ -2331,14 +2341,5 @@ export const TESTNET_TOKENS: TokensConfig = { Solana: 9, default: 8, }, - ntt: { - groupId: 'test_ntt', - nttManager: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', - // The wormhole transceiver is baked into the Solana NTT contract. - // If the transceiver is split into a separate contract, this address - // and route code should be updated to support the new structure. - wormholeTransceiver: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', - solanaQuoter: 'NqTdGLLL6b6bFo7YESNEezocgF8onH5cst5EdH791en', - }, }, }; diff --git a/wormhole-connect/src/config/types.ts b/wormhole-connect/src/config/types.ts index f92b7633d..d9de9742d 100644 --- a/wormhole-connect/src/config/types.ts +++ b/wormhole-connect/src/config/types.ts @@ -174,6 +174,9 @@ export interface InternalConfig { // Route settings ethBridgeMaxAmount: number; wstETHBridgeMaxAmount: number; + + // NTT config + nttGroups: NttGroups; } export type ExplorerConfig = { @@ -236,12 +239,6 @@ export type TokenConfig = { decimals: number; }; }; - ntt?: { - groupId: string; - nttManager: string; - wormholeTransceiver: string; - solanaQuoter?: string; - }; }; export type TokensConfig = { [key: string]: TokenConfig }; @@ -284,6 +281,7 @@ export type NetworkData = { rpcs: RpcMapping; rest: RpcMapping; graphql: RpcMapping; + nttGroups: NttGroups; }; export interface MenuEntry { @@ -292,3 +290,22 @@ export interface MenuEntry { target?: string; order?: number; } + +export type NttTransceiverConfig = { + address: string; + type: 'wormhole'; // only wormhole is supported for now +}; + +export type NttManagerConfig = { + chainName: ChainName; + address: string; + tokenKey: string; // token key for the token this NTT manager has configured + transceivers: NttTransceiverConfig[]; + solanaQuoter?: string; +}; + +export type NttGroup = { + nttManagers: NttManagerConfig[]; +}; + +export type NttGroups = { [key: string]: NttGroup }; diff --git a/wormhole-connect/src/routes/abstracts/routeAbstract.ts b/wormhole-connect/src/routes/abstracts/routeAbstract.ts index fae0671ba..e921086c6 100644 --- a/wormhole-connect/src/routes/abstracts/routeAbstract.ts +++ b/wormhole-connect/src/routes/abstracts/routeAbstract.ts @@ -179,6 +179,7 @@ export abstract class RouteAbstract { abstract getForeignAsset( token: TokenId, chain: ChainName | ChainId, + destToken?: TokenConfig, ): Promise; abstract getMessage( diff --git a/wormhole-connect/src/routes/bridge/baseRoute.ts b/wormhole-connect/src/routes/bridge/baseRoute.ts index b62c07964..86c268b3a 100644 --- a/wormhole-connect/src/routes/bridge/baseRoute.ts +++ b/wormhole-connect/src/routes/bridge/baseRoute.ts @@ -47,9 +47,6 @@ export abstract class BaseRoute extends RouteAbstract { if (isTBTCToken(token) && token.nativeChain !== chainName) { return false; } - if (token.ntt) { - return false; - } return true; } @@ -63,7 +60,6 @@ export abstract class BaseRoute extends RouteAbstract { if (!token.tokenId) return false; if (destChain && isIlliquidDestToken(token, destChain)) return false; if (isTBTCToken(token)) return false; - if (token.ntt) return false; if (sourceToken) { const wrapped = getWrappedToken(sourceToken); return wrapped.key === token.key; diff --git a/wormhole-connect/src/routes/bridge/bridge.ts b/wormhole-connect/src/routes/bridge/bridge.ts index 8b1e65e49..5b712d77f 100644 --- a/wormhole-connect/src/routes/bridge/bridge.ts +++ b/wormhole-connect/src/routes/bridge/bridge.ts @@ -7,7 +7,7 @@ import { import { BigNumber } from 'ethers'; import { hexlify, parseUnits, arrayify } from 'ethers/lib/utils.js'; import config from 'config'; -import { Route } from 'config/types'; +import { Route, TokenConfig } from 'config/types'; import { getTokenDecimals } from 'utils'; import { TransferWallet, postVaa, signAndSendTransaction } from 'utils/wallet'; import { @@ -61,8 +61,6 @@ export class BridgeRoute extends BaseRoute { ) return false; - if (sourceTokenConfig.ntt) return false; - if (!!sourceTokenConfig.tokenId && sourceToken === destToken) return true; if ( !sourceTokenConfig.tokenId && @@ -247,6 +245,7 @@ export class BridgeRoute extends BaseRoute { async getForeignAsset( token: TokenId, chain: ChainName | ChainId, + destToken?: TokenConfig, ): Promise { return config.wh.getForeignAsset(token, chain); } diff --git a/wormhole-connect/src/routes/cctpManual/cctpManual.ts b/wormhole-connect/src/routes/cctpManual/cctpManual.ts index c5e6a8953..ba42512db 100644 --- a/wormhole-connect/src/routes/cctpManual/cctpManual.ts +++ b/wormhole-connect/src/routes/cctpManual/cctpManual.ts @@ -382,6 +382,7 @@ export class CCTPManualRoute extends BaseRoute { async getForeignAsset( token: TokenId, chain: ChainName | ChainId, + destToken?: TokenConfig, ): Promise { // assumes USDC const addr = config.tokensArr.find( diff --git a/wormhole-connect/src/routes/cctpManual/utils/chains.ts b/wormhole-connect/src/routes/cctpManual/utils/chains.ts index 90ac1043e..0e65175c0 100644 --- a/wormhole-connect/src/routes/cctpManual/utils/chains.ts +++ b/wormhole-connect/src/routes/cctpManual/utils/chains.ts @@ -5,7 +5,7 @@ export const CCTPManual_CHAINS: ChainName[] = [ 'ethereum', 'avalanche', 'fuji', - 'goerli', + 'sepolia', 'base', 'optimism', 'arbitrum', @@ -21,7 +21,7 @@ export const CCTPDomains: Partial> = { ethereum: 0, avalanche: 1, fuji: 1, - goerli: 0, + sepolia: 0, base: 6, optimism: 2, arbitrum: 3, @@ -36,7 +36,7 @@ export const CCTPDomains: Partial> = { export function getChainNameCCTP(domain: number): ChainName { switch (domain) { case 0: - return config.isMainnet ? 'ethereum' : 'goerli'; + return config.isMainnet ? 'ethereum' : 'sepolia'; case 1: return config.isMainnet ? 'avalanche' : 'fuji'; case 2: diff --git a/wormhole-connect/src/routes/cosmosGateway/cosmosGateway.ts b/wormhole-connect/src/routes/cosmosGateway/cosmosGateway.ts index c2b6028b5..f639310b1 100644 --- a/wormhole-connect/src/routes/cosmosGateway/cosmosGateway.ts +++ b/wormhole-connect/src/routes/cosmosGateway/cosmosGateway.ts @@ -143,6 +143,7 @@ export class CosmosGatewayRoute extends BaseRoute { getForeignAsset( token: TokenId, chain: ChainId | ChainName, + destToken?: TokenConfig, ): Promise { return config.wh.getForeignAsset(token, chain); } diff --git a/wormhole-connect/src/routes/hashflow/hashflow.ts b/wormhole-connect/src/routes/hashflow/hashflow.ts index 3f1400fb1..7e0a1e607 100644 --- a/wormhole-connect/src/routes/hashflow/hashflow.ts +++ b/wormhole-connect/src/routes/hashflow/hashflow.ts @@ -144,6 +144,7 @@ export class HashflowRoute extends RouteAbstract { getForeignAsset( token: TokenId, chain: ChainName | ChainId, + destToken?: TokenConfig, ): Promise { throw new Error('Method not implemented.'); } diff --git a/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts b/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts index 60980d988..09e1e828b 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts @@ -8,7 +8,6 @@ import { import { ethers } from 'ethers'; import { hexlify } from 'ethers/lib/utils'; import { NttRelayingType, UnsignedNttMessage } from 'routes/types'; -import { getNttToken } from 'store/transferInput'; import { getTokenById, getTokenDecimals } from 'utils'; import { getWormholeLogEvm } from 'utils/vaa'; import { NttManager__factory } from './abis'; @@ -16,6 +15,11 @@ import config from 'config'; import { toChainName } from 'utils/sdk'; import { deserializePayload, Ntt } from '@wormhole-foundation/sdk-definitions'; import { toChain, toChainId } from '@wormhole-foundation/sdk-base'; +import { + getNttGroupKeyByAddress, + getNttManagerConfigByGroupKey, + isNttToken, +} from 'utils/ntt'; const RELAYING_INFO_EVENT_TOPIC = '0x375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271'; @@ -31,9 +35,7 @@ export const getMessageEvm = async ( const provider = config.wh.mustGetProvider(chain); if (!receipt) { receipt = await provider.getTransactionReceipt(tx); - if (!receipt) { - throw new Error(`No receipt for tx ${tx} on ${chain}`); - } + if (!receipt) throw new Error(`No receipt for tx ${tx} on ${chain}`); } const nttManager = NttManager__factory.connect(receipt.to, provider); const tokenAddress = await nttManager.token(); @@ -43,18 +45,15 @@ export const getMessageEvm = async ( address: tokenAddress, }; const token = getTokenById(tokenId); - if (!token?.ntt) { - throw new Error(`Token ${tokenId} not found`); - } + if (!token || !isNttToken(token)) + throw new Error(`Token ${tokenId} is not an NTT token`); const wormholeLog = await getWormholeLogEvm(fromChain, receipt); const parsedWormholeLog = Implementation__factory.createInterface().parseLog(wormholeLog); const relayingInfoEvent = receipt.logs.find( (log) => log.topics[0] === RELAYING_INFO_EVENT_TOPIC, ); - if (!relayingInfoEvent) { - throw new Error('RelayingInfo event not found'); - } + if (!relayingInfoEvent) throw new Error('RelayingInfo event not found'); const parsedRelayingInfo = RELAYING_INFO_IFACE.parseLog(relayingInfoEvent); const { relayingType, deliveryPayment } = parsedRelayingInfo.args; let payload: Buffer; @@ -80,10 +79,17 @@ export const getMessageEvm = async ( const recipientChain = toChainName( toChainId(nttManagerMessage.payload.recipientChain) as ChainId, ); - const receivedTokenKey = getNttToken(token.ntt.groupId, recipientChain); - if (!receivedTokenKey) { + const groupKey = getNttGroupKeyByAddress(receipt.to, fromChain); + if (!groupKey) throw new Error(`No NTT group key for ${receipt.to}`); + const recipientNttManagerConfig = getNttManagerConfigByGroupKey( + groupKey, + recipientChain, + ); + if (!recipientNttManagerConfig) + throw new Error('Recipient NTT manager not found'); + const receivedTokenKey = recipientNttManagerConfig.tokenKey; + if (!receivedTokenKey) throw new Error(`Received token key not found for ${tokenId}`); - } return { sendTx: receipt.transactionHash, sender: receipt.from, diff --git a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts index 273a44c82..334f57fa1 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts @@ -23,6 +23,7 @@ import { NttManager__factory } from './abis/NttManager__factory'; import { NttManager as NttManagerAbi } from './abis/NttManager'; import config from 'config'; import { toChainId, toChainName } from 'utils/sdk'; +import { getNttManagerConfigByAddress } from 'utils/ntt'; export class NttManagerEvm { readonly nttManager: NttManagerAbi; @@ -89,16 +90,18 @@ export class NttManagerEvm { shouldSkipRelayerSend: boolean, ): Promise { const tokenConfig = getTokenById(token); - if (!tokenConfig?.ntt?.wormholeTransceiver) { + if (!tokenConfig) throw new Error('token not found'); + const nttConfig = getNttManagerConfigByAddress( + this.nttManager.address, + toChainName(this.chain), + ); + if (!nttConfig || nttConfig.transceivers[0].type !== 'wormhole') throw new Error('no wormhole transceiver'); - } + const wormholeTransceiver = nttConfig.transceivers[0].address; const deliveryPrice = shouldSkipRelayerSend ? undefined : BigNumber.from( - await this.quoteDeliveryPrice( - toChain, - tokenConfig.ntt.wormholeTransceiver, - ), + await this.quoteDeliveryPrice(toChain, wormholeTransceiver), ); const transceiverIxs = encodeTransceiverInstructions([ { diff --git a/wormhole-connect/src/routes/ntt/chains/solana/getMessage.ts b/wormhole-connect/src/routes/ntt/chains/solana/getMessage.ts index a8df48b30..81504be3f 100644 --- a/wormhole-connect/src/routes/ntt/chains/solana/getMessage.ts +++ b/wormhole-connect/src/routes/ntt/chains/solana/getMessage.ts @@ -2,12 +2,17 @@ import { solanaContext } from 'utils/sdk'; import { PostedMessageData } from '@certusone/wormhole-sdk/lib/esm/solana/wormhole'; import { hexlify } from 'ethers/lib/utils'; import { NttRelayingType, UnsignedNttMessage } from 'routes/types'; -import { getNttToken } from 'store/transferInput'; import { getTokenById, getTokenDecimals } from 'utils'; import config from 'config'; import { deserializePayload, Ntt } from '@wormhole-foundation/sdk-definitions'; import { toChainId } from '@wormhole-foundation/sdk-base'; import { ChainName } from '@wormhole-foundation/wormhole-connect-sdk'; +import { + getNttGroupKeyByAddress, + getNttManagerConfigByGroupKey, + isNttToken, +} from 'utils/ntt'; +import { PublicKey } from '@solana/web3.js'; export const getMessageSolana = async ( tx: string, @@ -31,9 +36,8 @@ export const getMessageSolana = async ( const wormholeMessageAccount = await connection.getAccountInfo( wormholeMessageAccountKey, ); - if (wormholeMessageAccount === null) { + if (wormholeMessageAccount === null) throw new Error('wormhole message account not found'); - } const messageData = PostedMessageData.deserialize( wormholeMessageAccount.data, ); @@ -54,13 +58,24 @@ export const getMessageSolana = async ( address: tokenAddress, }; const token = getTokenById(tokenId); - if (!token?.ntt) { - throw new Error(`Token ${tokenId} not found`); - } - const receivedTokenKey = getNttToken(token.ntt.groupId, recipientChain); - if (!receivedTokenKey) { + if (!token || !isNttToken(token)) + throw new Error(`Token ${tokenId} is not an NTT token`); + const groupKey = getNttGroupKeyByAddress( + new PublicKey( + transceiverMessage.sourceNttManager.toUint8Array(), + ).toString(), + fromChain, + ); + if (!groupKey) throw new Error('Group key not found'); + const recipientNttManagerConfig = getNttManagerConfigByGroupKey( + groupKey, + recipientChain, + ); + if (!recipientNttManagerConfig) + throw new Error('Recipient NTT manager not found'); + const receivedTokenKey = recipientNttManagerConfig.tokenKey; + if (!receivedTokenKey) throw new Error(`Received token key not found for ${tokenId}`); - } const logMsgs = response.meta?.logMessages || []; const regex = /total fee in lamports: (\d+)/; const relayerFeeMsg = logMsgs.find((msg) => regex.test(msg)); diff --git a/wormhole-connect/src/routes/ntt/chains/solana/nttManager.ts b/wormhole-connect/src/routes/ntt/chains/solana/nttManager.ts index a28bcfad3..7ec872d8d 100644 --- a/wormhole-connect/src/routes/ntt/chains/solana/nttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/solana/nttManager.ts @@ -33,11 +33,11 @@ import { } from '@certusone/wormhole-sdk/lib/esm/solana/wormhole'; import { associatedAddress } from '@coral-xyz/anchor/dist/esm/utils/token'; import { NttQuoter } from './nttQuoter'; -import { getTokenById } from 'utils'; import { Keccak } from 'sha3'; import CONFIG from 'config'; import { toChain as SDKv2toChain } from '@wormhole-foundation/sdk-base'; import { hexlify } from 'ethers/lib/utils'; +import { getNttManagerConfigByAddress } from 'utils/ntt'; // TODO: make sure this is in sync with the contract const RATE_LIMIT_DURATION = 24 * 60 * 60; @@ -124,11 +124,12 @@ export class NttManagerSolana { const tx = new Transaction(); tx.add(approveIx, transferIx, releaseIx); if (!shouldSkipRelayerSend) { - const { ntt } = getTokenById(token) || {}; - if (!ntt?.solanaQuoter) { - throw new Error(`no solana quoter for token: ${token}`); - } - const quoter = new NttQuoter(ntt.solanaQuoter); + const nttConfig = getNttManagerConfigByAddress( + this.program.programId.toString(), + 'solana', + ); + if (!nttConfig || !nttConfig.solanaQuoter) throw new Error('no quoter'); + const quoter = new NttQuoter(nttConfig.solanaQuoter); const fee = await quoter.calcRelayCost(toChain); const relayIx = await quoter.createRequestRelayInstruction( payer, @@ -207,7 +208,9 @@ export class NttManagerSolana { const releaseArgs = { ...redeemArgs, messageDigest: hexlify(messageDigest), - recipient: new PublicKey(nttManagerPayload.payload.recipientAddress), + recipient: new PublicKey( + nttManagerPayload.payload.recipientAddress.toUint8Array(), + ), chain: chainId, revertOnDelay: false, }; diff --git a/wormhole-connect/src/routes/ntt/nttBase.ts b/wormhole-connect/src/routes/ntt/nttBase.ts index 6413ef69e..e5f7e1da8 100644 --- a/wormhole-connect/src/routes/ntt/nttBase.ts +++ b/wormhole-connect/src/routes/ntt/nttBase.ts @@ -28,7 +28,6 @@ import { removeDust, toNormalizedDecimals, } from 'utils'; -import { getNttToken } from 'store/transferInput'; import { getNttManager } from './chains'; import { InboundQueuedTransfer } from './types'; import { @@ -41,6 +40,13 @@ import { formatGasFee } from 'routes/utils'; import { NO_INPUT } from 'utils/style'; import { estimateAverageGasFee } from 'utils/gas'; import config from 'config'; +import { + getNttGroupKey, + getNttManagerAddress, + getNttManagerConfigByAddress, + isNttToken, + isNttTokenPair, +} from 'utils/ntt'; export abstract class NttBase extends BaseRoute { isSupportedChain(chain: ChainName): boolean { @@ -53,14 +59,18 @@ export abstract class NttBase extends BaseRoute { sourceChain?: ChainName | ChainId, destChain?: ChainName | ChainId, ): Promise { - if (!token || !sourceChain || !this.isSupportedToken(token, sourceChain)) { + if ( + !token || + !isNttToken(token) || + !sourceChain || + !this.isSupportedToken(token, sourceChain) + ) { return false; } if ( - destChain && destToken && - !this.isSupportedToken(destToken, destChain) && - token.symbol === destToken.symbol + ((destChain && !this.isSupportedToken(destToken, destChain)) || + !isNttTokenPair(destToken, token)) ) { return false; } @@ -73,14 +83,18 @@ export abstract class NttBase extends BaseRoute { sourceChain?: ChainName | ChainId, destChain?: ChainName | ChainId, ): Promise { - if (!token || !destChain || !this.isSupportedToken(token, destChain)) { + if ( + !token || + !isNttToken(token) || + !destChain || + !this.isSupportedToken(token, destChain) + ) { return false; } if ( - sourceChain && sourceToken && - !this.isSupportedToken(sourceToken, sourceChain) && - token.symbol === sourceToken.symbol + ((sourceChain && !this.isSupportedToken(sourceToken, sourceChain)) || + !isNttTokenPair(sourceToken, token)) ) { return false; } @@ -90,7 +104,7 @@ export abstract class NttBase extends BaseRoute { isSupportedToken(token: TokenConfig, chain: ChainName | ChainId): boolean { return ( this.isSupportedChain(token.nativeChain) && - !!token.ntt && + isNttToken(token) && toChainName(chain) === token.nativeChain ); } @@ -102,7 +116,6 @@ export abstract class NttBase extends BaseRoute { sourceChain: ChainName | ChainId, destChain: ChainName | ChainId, ): Promise { - console.log('isRouteSupported'); return await Promise.all([ this.isSupportedChain(toChainName(sourceChain)), this.isSupportedChain(toChainName(destChain)), @@ -198,26 +211,28 @@ export abstract class NttBase extends BaseRoute { destToken: string, routeOptions: any, ): Promise { - if (token === 'native') { - throw new Error('invalid token'); - } + if (token === 'native') throw new Error('invalid token'); const tokenConfig = getTokenById(token); - if (!tokenConfig?.ntt) { + if (!tokenConfig || !isNttToken(tokenConfig)) throw new Error('invalid token'); - } const destTokenConfig = config.tokens[destToken]; - if (!destTokenConfig?.ntt) { - throw new Error('invalid dest token'); - } + if (!isNttToken(destTokenConfig)) throw new Error('invalid dest token'); + const nttGroupKey = getNttGroupKey(tokenConfig, destTokenConfig); + if (!nttGroupKey) throw new Error('invalid token pair'); + const recipientNttManagerAddress = getNttManagerAddress( + destTokenConfig, + nttGroupKey, + ); + if (!recipientNttManagerAddress) + throw new Error('recipient ntt manager not found'); if ( - await getNttManager( - recipientChain, - destTokenConfig.ntt.nttManager, - ).isPaused() + await getNttManager(recipientChain, recipientNttManagerAddress).isPaused() ) { throw new DestinationContractIsPausedError(); } - const nttManager = getNttManager(sendingChain, tokenConfig.ntt.nttManager); + const nttManagerAddress = getNttManagerAddress(tokenConfig, nttGroupKey); + if (!nttManagerAddress) throw new Error('ntt manager not found'); + const nttManager = getNttManager(sendingChain, nttManagerAddress); if (await nttManager.isPaused()) { throw new ContractIsPausedError(); } @@ -246,28 +261,26 @@ export abstract class NttBase extends BaseRoute { signedMessage: SignedMessage, payer: string, ): Promise { - if (!isSignedNttMessage(signedMessage)) { + if (!isSignedNttMessage(signedMessage)) throw new Error('Not a signed NttMessage'); - } - const { recipientNttManager, receivedTokenKey, vaa } = signedMessage; + const { recipientNttManager, vaa } = signedMessage; const nttManager = getNttManager(chain, recipientNttManager); - if (await nttManager.isPaused()) { - throw new ContractIsPausedError(); - } - const nttConfig = config.tokens[receivedTokenKey]?.ntt; - if (!nttConfig) { - throw new Error('ntt config not found'); - } + if (await nttManager.isPaused()) throw new ContractIsPausedError(); + const nttConfig = getNttManagerConfigByAddress( + recipientNttManager, + toChainName(chain), + ); + if (!nttConfig) throw new Error('ntt config not found'); if (isEvmChain(chain)) { + if (nttConfig.transceivers[0].type !== 'wormhole') + throw new Error('Unsupported transceiver type'); const transceiver = new WormholeTransceiver( chain, - nttConfig.wormholeTransceiver, + nttConfig.transceivers[0].address, ); return await transceiver.receiveMessage(vaa, payer); - } - if (toChainName(chain) === 'solana') { + } else if (toChainName(chain) === 'solana') return await (nttManager as NttManagerSolana).receiveMessage(vaa, payer); - } throw new Error('Unsupported chain'); } @@ -340,13 +353,9 @@ export abstract class NttBase extends BaseRoute { async getForeignAsset( token: TokenId, chain: ChainName | ChainId, + destToken?: TokenConfig, ): Promise { - const tokenConfig = getTokenById(token); - if (!tokenConfig?.ntt) { - throw new Error('invalid token'); - } - const key = getNttToken(tokenConfig.ntt.groupId, chain); - return config.tokens[key]?.tokenId?.address || null; + return destToken?.tokenId?.address || null; } async getMessage( diff --git a/wormhole-connect/src/routes/ntt/nttRelay.ts b/wormhole-connect/src/routes/ntt/nttRelay.ts index c40a7fba3..d0d563223 100644 --- a/wormhole-connect/src/routes/ntt/nttRelay.ts +++ b/wormhole-connect/src/routes/ntt/nttRelay.ts @@ -29,6 +29,12 @@ import { toDecimals, toFixedDecimals } from 'utils/balance'; import { NttManagerEvm, WormholeTransceiver } from './chains/evm'; import { NttQuoter } from './chains/solana/nttQuoter'; import config from 'config'; +import { + getNttGroupKey, + getNttManagerAddress, + getNttManagerConfig, + getNttManagerConfigByAddress, +} from 'utils/ntt'; export class NttRelay extends NttBase { readonly NATIVE_GAS_DROPOFF_SUPPORTED: boolean = false; @@ -42,10 +48,13 @@ export class NttRelay extends NttBase { sourceChain: ChainName | ChainId, destChain: ChainName | ChainId, ): Promise { - const nttConfig = config.tokens[sourceToken]?.ntt; - if (!nttConfig) { - return false; - } + const groupKey = getNttGroupKey( + config.tokens[sourceToken], + config.tokens[destToken], + ); + if (!groupKey) return false; + const nttConfig = getNttManagerConfig(config.tokens[sourceToken], groupKey); + if (!nttConfig) return false; if ( !(await super.isRouteSupported( sourceToken, @@ -58,9 +67,10 @@ export class NttRelay extends NttBase { return false; } if (isEvmChain(sourceChain)) { + if (nttConfig.transceivers[0].type !== 'wormhole') return false; const transceiver = new WormholeTransceiver( sourceChain, - nttConfig.wormholeTransceiver, + nttConfig.transceivers[0].address, ); return await Promise.all([ transceiver.isWormholeRelayingEnabled(destChain), @@ -81,15 +91,28 @@ export class NttRelay extends NttBase { token: string, destToken: string, ): Promise { - const nttConfig = config.tokens[token]?.ntt; - if (!nttConfig) { - throw new Error('invalid token'); - } + const groupKey = getNttGroupKey( + config.tokens[token], + config.tokens[destToken], + ); + if (!groupKey) throw new Error('no ntt group'); + const nttManagerAddress = getNttManagerAddress( + config.tokens[token], + groupKey, + ); + if (!nttManagerAddress) throw new Error('no ntt manager address'); + const nttConfig = getNttManagerConfigByAddress( + nttManagerAddress, + toChainName(sourceChain), + ); + if (!nttConfig) throw new Error('no ntt config'); if (isEvmChain(sourceChain)) { - const nttManager = new NttManagerEvm(sourceChain, nttConfig.nttManager); + const nttManager = new NttManagerEvm(sourceChain, nttManagerAddress); + if (nttConfig.transceivers[0].type !== 'wormhole') + throw new Error('no wormhole transceiver'); const deliveryPrice = await nttManager.quoteDeliveryPrice( destChain, - nttConfig.wormholeTransceiver, + nttConfig.transceivers[0].address, ); return { fee: BigNumber.from(deliveryPrice), feeToken: 'native' }; } diff --git a/wormhole-connect/src/routes/operator.ts b/wormhole-connect/src/routes/operator.ts index a414503f1..38d33efeb 100644 --- a/wormhole-connect/src/routes/operator.ts +++ b/wormhole-connect/src/routes/operator.ts @@ -39,6 +39,7 @@ import { TokenPrices } from 'store/tokenPrices'; import { NttManual, NttRelay } from './ntt'; import { getMessageEvm } from './ntt/chains/evm'; import { getMessageSolana } from './ntt/chains/solana'; +import { getNttManagerConfigByAddress } from 'utils/ntt'; export class Operator { getRoute(route: Route): RouteAbstract { @@ -110,7 +111,7 @@ export class Operator { // Check if is Ntt Route (NttRelay or NttManual) if ( - config.tokensArr.some(({ ntt }) => ntt && ntt.nttManager === receipt.to) + getNttManagerConfigByAddress(receipt.to, config.wh.toChainName(chain)) ) { const { relayingType } = await getMessageEvm(txHash, chain, receipt); return relayingType === NttRelayingType.Manual @@ -127,9 +128,7 @@ export class Operator { if (!tx) throw new Error('Transaction not found'); if ( tx.transaction.message.instructions.some((ix) => - config.tokensArr.some( - ({ ntt }) => ntt && ntt.nttManager === ix.programId.toString(), - ), + getNttManagerConfigByAddress(ix.programId.toString(), chain), ) ) { const { relayingType } = await getMessageSolana(txHash); @@ -571,9 +570,10 @@ export class Operator { route: Route, tokenId: TokenId, chain: ChainName | ChainId, + destToken?: TokenConfig, ): Promise { const r = this.getRoute(route); - return r.getForeignAsset(tokenId, chain); + return r.getForeignAsset(tokenId, chain, destToken); } async isTransferCompleted( diff --git a/wormhole-connect/src/routes/porticoBridge/porticoBridge.ts b/wormhole-connect/src/routes/porticoBridge/porticoBridge.ts index de119599c..c6779e530 100644 --- a/wormhole-connect/src/routes/porticoBridge/porticoBridge.ts +++ b/wormhole-connect/src/routes/porticoBridge/porticoBridge.ts @@ -599,6 +599,7 @@ export abstract class PorticoBridge extends BaseRoute { async getForeignAsset( token: TokenId, chain: ChainName | ChainId, + destToken?: TokenConfig, ): Promise { return await config.wh.getForeignAsset(token, chain); } diff --git a/wormhole-connect/src/routes/tbtc/tbtc.ts b/wormhole-connect/src/routes/tbtc/tbtc.ts index dcb6f69aa..405680f72 100644 --- a/wormhole-connect/src/routes/tbtc/tbtc.ts +++ b/wormhole-connect/src/routes/tbtc/tbtc.ts @@ -421,6 +421,7 @@ export class TBTCRoute extends BaseRoute { async getForeignAsset( token: TokenId, chain: ChainName | ChainId, + destToken?: TokenConfig, ): Promise { const chainId = config.wh.toChainId(chain); if (isTBTCCanonicalChain(chainId)) { diff --git a/wormhole-connect/src/routes/utils.ts b/wormhole-connect/src/routes/utils.ts index 683424110..ee0c307d2 100644 --- a/wormhole-connect/src/routes/utils.ts +++ b/wormhole-connect/src/routes/utils.ts @@ -87,6 +87,16 @@ export const isIlliquidDestToken = ( return true; } } + if ( + symbol === 'USDC' && + nativeChain === 'sepolia' && + destChain === 'alfajores' + ) { + return true; + } + if (['TEST_NTT', 'USDCalfaljores'].includes(symbol)) { + return true; + } return false; }; diff --git a/wormhole-connect/src/store/transferInput.ts b/wormhole-connect/src/store/transferInput.ts index e9083f614..eebaeb380 100644 --- a/wormhole-connect/src/store/transferInput.ts +++ b/wormhole-connect/src/store/transferInput.ts @@ -1,9 +1,5 @@ import { createSlice, PayloadAction } from '@reduxjs/toolkit'; -import { - ChainName, - ChainId, - Context, -} from '@wormhole-foundation/wormhole-connect-sdk'; +import { ChainName, Context } from '@wormhole-foundation/wormhole-connect-sdk'; import { BigNumber } from 'ethers'; import config from 'config'; import { Route, TokenConfig } from 'config/types'; @@ -24,6 +20,8 @@ import { receiveDataWrapper, } from './helpers'; import { isPorticoRoute } from 'routes/porticoBridge/utils'; +import { isNttRoute } from 'routes'; +import { getNttGroupKey, getNttTokenByGroupKey } from 'utils/ntt'; export type Balances = { [key: string]: string | null }; export type ChainBalances = { @@ -59,19 +57,6 @@ export const getNativeVersionOfToken = ( ); }; -// get the token key for the NTT token for a given group and chain -export const getNttToken = ( - groupId: string, - chain: ChainName | ChainId, -): string => { - return ( - Object.entries(config.tokens) - .map(([key, t]) => t) - .find((t) => t.ntt?.groupId === groupId && t.nativeChain === chain) - ?.key || '' - ); -}; - export const accessChainBalances = ( balances: WalletBalances | undefined, walletAddress: WalletAddress | undefined, @@ -186,7 +171,7 @@ function getInitialState(): TransferInputState { } const performModificationsIfFromChainChanged = (state: TransferInputState) => { - const { fromChain, token, route } = state; + const { fromChain, token, route, destToken } = state; if (token) { const tokenConfig = config.tokens[token]; // clear token and amount if not supported on the selected network @@ -216,14 +201,19 @@ const performModificationsIfFromChainChanged = (state: TransferInputState) => { if (tokenConfig.nativeChain !== fromChain) { state.token = getNativeVersionOfToken(tokenConfig.symbol, fromChain!); } - } else if (tokenConfig.ntt && tokenConfig.nativeChain !== fromChain) { - state.token = getNttToken(tokenConfig.ntt.groupId, fromChain!); + } else if (isNttRoute(route) && destToken) { + const groupKey = getNttGroupKey(tokenConfig, config.tokens[destToken]); + if (groupKey) { + state.token = getNttTokenByGroupKey(groupKey, fromChain!)?.key || ''; + } else { + state.token = ''; + } } } }; const performModificationsIfToChainChanged = (state: TransferInputState) => { - const { toChain, destToken, route } = state; + const { toChain, destToken, route, token } = state; if (destToken) { const tokenConfig = config.tokens[destToken]; @@ -244,8 +234,13 @@ const performModificationsIfToChainChanged = (state: TransferInputState) => { if (tokenConfig.nativeChain !== toChain) { state.destToken = getNativeVersionOfToken(tokenConfig.symbol, toChain!); } - } else if (tokenConfig.ntt && tokenConfig.nativeChain !== toChain) { - state.destToken = getNttToken(tokenConfig.ntt.groupId, toChain!); + } else if (isNttRoute(route) && token) { + const groupKey = getNttGroupKey(tokenConfig, config.tokens[token]); + if (groupKey) { + state.destToken = getNttTokenByGroupKey(groupKey, toChain!)?.key || ''; + } else { + state.destToken = ''; + } } } }; diff --git a/wormhole-connect/src/utils/ntt.ts b/wormhole-connect/src/utils/ntt.ts new file mode 100644 index 000000000..34aa8e26b --- /dev/null +++ b/wormhole-connect/src/utils/ntt.ts @@ -0,0 +1,124 @@ +import config from 'config'; +import { NttManagerConfig, TokenConfig } from 'config/types'; +import { ChainName } from '@wormhole-foundation/wormhole-connect-sdk'; +import { isEqualCaseInsensitive } from 'utils'; + +export const isNttToken = (token: TokenConfig): boolean => { + if (!token) return false; + return Object.values(config.nttGroups).some((group) => + group.nttManagers.some( + (manager) => + manager.tokenKey === token.key && + manager.chainName === token.nativeChain, + ), + ); +}; + +export const isNttTokenPair = ( + token1: TokenConfig, + token2: TokenConfig, +): boolean => { + if (!token1 || !token2) return false; + // Find the groups that token1 belongs to + const token1Groups = Object.values(config.nttGroups).filter((group) => + group.nttManagers.some( + (manager) => + manager.tokenKey === token1.key && + manager.chainName === token1.nativeChain, + ), + ); + // then check if token2 belongs to any of those groups + return token1Groups.some((group) => + group.nttManagers.some( + (manager) => + manager.tokenKey === token2.key && + manager.chainName === token2.nativeChain, + ), + ); +}; + +export const getNttManagerConfig = ( + token: TokenConfig, + groupKey: string, +): NttManagerConfig | undefined => { + if (!token) return; + const group = config.nttGroups[groupKey]; + if (!group) return; + return group.nttManagers.find( + (manager) => + manager.tokenKey === token.key && manager.chainName === token.nativeChain, + ); +}; + +export const getNttManagerAddress = ( + token: TokenConfig, + groupKey: string, +): string | undefined => { + return getNttManagerConfig(token, groupKey)?.address; +}; + +export const getNttGroupKey = ( + token1: TokenConfig, + token2: TokenConfig, +): string | undefined => { + if (!token1 || !token2) return; + const [key] = + Object.entries(config.nttGroups).find( + ([, group]) => + group.nttManagers.some( + (manager) => + manager.tokenKey === token1.key && + manager.chainName === token1.nativeChain, + ) && + group.nttManagers.some( + (manager) => + manager.tokenKey === token2.key && + manager.chainName === token2.nativeChain, + ), + ) || []; + return key; +}; + +export const getNttGroupKeyByAddress = ( + managerAddress: string, + chainName: ChainName, +): string | undefined => { + return Object.entries(config.nttGroups).find(([, group]) => + group.nttManagers.some( + (manager) => + isEqualCaseInsensitive(manager.address, managerAddress) && + manager.chainName === chainName, + ), + )?.[0]; +}; + +export const getNttManagerConfigByAddress = ( + managerAddress: string, + chainName: ChainName, +): NttManagerConfig | undefined => { + return Object.values(config.nttGroups).flatMap((group) => + group.nttManagers.filter( + (manager) => + isEqualCaseInsensitive(manager.address, managerAddress) && + manager.chainName === chainName, + ), + )[0]; +}; + +export const getNttManagerConfigByGroupKey = ( + groupKey: string, + chainName: ChainName, +): NttManagerConfig | undefined => { + return config.nttGroups[groupKey].nttManagers.find( + (manager) => manager.chainName === chainName, + ); +}; + +export const getNttTokenByGroupKey = ( + groupKey: string, + chainName: ChainName, +): TokenConfig | undefined => { + const manager = getNttManagerConfigByGroupKey(groupKey, chainName); + if (!manager) return; + return config.tokens[manager.tokenKey]; +}; diff --git a/wormhole-connect/src/views/Bridge/Inputs/TokenWarnings.tsx b/wormhole-connect/src/views/Bridge/Inputs/TokenWarnings.tsx index ab18aa3c0..53d755e4a 100644 --- a/wormhole-connect/src/views/Bridge/Inputs/TokenWarnings.tsx +++ b/wormhole-connect/src/views/Bridge/Inputs/TokenWarnings.tsx @@ -133,6 +133,7 @@ function TokenWarnings() { route, tokenId, toChain, + destTokenConfig, ); if (!active) return; @@ -148,7 +149,7 @@ function TokenWarnings() { return () => { active = false; }; - }, [toChain, tokenConfig, route, dispatch]); + }, [toChain, tokenConfig, route, destTokenConfig, dispatch]); // the associated token account address is deterministic, so we still // need to check if there is an account created for that address diff --git a/wormhole-connect/src/views/Bridge/NttInboundCapacityWarning.tsx b/wormhole-connect/src/views/Bridge/NttInboundCapacityWarning.tsx index 275f8800e..dd84484a9 100644 --- a/wormhole-connect/src/views/Bridge/NttInboundCapacityWarning.tsx +++ b/wormhole-connect/src/views/Bridge/NttInboundCapacityWarning.tsx @@ -4,10 +4,10 @@ import { NttManual } from 'routes/ntt'; import { parseUnits } from 'ethers/lib/utils'; import { getTokenDecimals } from 'utils'; import { BigNumber } from 'ethers'; -import { getNttToken } from 'store/transferInput'; import { useSelector } from 'react-redux'; import { RootState } from 'store'; import config from 'config'; +import { getNttGroupKey, getNttManagerAddress, isNttToken } from 'utils/ntt'; function formatDuration(seconds: number) { if (seconds < 60) { @@ -22,13 +22,18 @@ function formatDuration(seconds: number) { } const NttInboundCapacityWarning = () => { - const { fromChain, toChain, destToken, receiveAmount } = useSelector( + const { fromChain, toChain, token, destToken, receiveAmount } = useSelector( (state: RootState) => state.transferInput, ); const amount = receiveAmount.data || '0'; const [capacity, setCapacity] = useState(undefined); const [duration, setDuration] = useState(0); - const nttManagerAddress = config.tokens[destToken]?.ntt?.nttManager; + const groupKey = getNttGroupKey( + config.tokens[token], + config.tokens[destToken], + ); + const nttManagerAddress = + groupKey && getNttManagerAddress(config.tokens[destToken], groupKey); useEffect(() => { if (!toChain || !nttManagerAddress || !fromChain) return; @@ -78,14 +83,12 @@ const NttInboundCapacityWarning = () => { !toChain || !capacity || !duration || - !fromChain + !fromChain || + !groupKey ) return false; - const groupId = config.tokens[destToken]?.ntt?.groupId; - if (!groupId) return false; - const destTokenKey = getNttToken(groupId, toChain); - const destTokenConfig = config.tokens[destTokenKey]; - if (!destTokenConfig) return false; + const destTokenConfig = config.tokens[destToken]; + if (!destTokenConfig || !isNttToken(destTokenConfig)) return false; // capacity is in destination token decimals, so we need to convert the amount to the same decimals const decimals = getTokenDecimals( config.wh.toChainId(toChain), @@ -94,7 +97,7 @@ const NttInboundCapacityWarning = () => { const parsedAmount = parseUnits(Number(amount).toFixed(decimals), decimals); const threshold = capacity.mul(95).div(100); // 95% of capacity return parsedAmount.gt(threshold); - }, [destToken, amount, toChain]); + }, [destToken, amount, toChain, groupKey]); if (!showWarning || !toChain) return null; From d883c05d8ba2a51fefd3d7b065c1dae31d343111 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Thu, 28 Mar 2024 16:48:16 -0500 Subject: [PATCH 06/17] usdc switch chains fix --- wormhole-connect/src/config/testnet/tokens.ts | 2 +- wormhole-connect/src/routes/utils.ts | 3 ++ wormhole-connect/src/store/transferInput.ts | 35 ++++++++++--------- 3 files changed, 23 insertions(+), 17 deletions(-) diff --git a/wormhole-connect/src/config/testnet/tokens.ts b/wormhole-connect/src/config/testnet/tokens.ts index f6a0696fd..72d859f47 100644 --- a/wormhole-connect/src/config/testnet/tokens.ts +++ b/wormhole-connect/src/config/testnet/tokens.ts @@ -902,7 +902,7 @@ export const TESTNET_TOKENS: TokensConfig = { }, USDCalfajores: { key: 'USDCalfajores', - symbol: 'USDC', + symbol: 'USDC.e', nativeChain: 'alfajores', icon: Icon.USDC, tokenId: { diff --git a/wormhole-connect/src/routes/utils.ts b/wormhole-connect/src/routes/utils.ts index ee0c307d2..822812ba5 100644 --- a/wormhole-connect/src/routes/utils.ts +++ b/wormhole-connect/src/routes/utils.ts @@ -94,6 +94,9 @@ export const isIlliquidDestToken = ( ) { return true; } + if (symbol === 'USDC.e' && nativeChain === 'alfajores') { + return true; + } if (['TEST_NTT', 'USDCalfaljores'].includes(symbol)) { return true; } diff --git a/wormhole-connect/src/store/transferInput.ts b/wormhole-connect/src/store/transferInput.ts index eebaeb380..3022e95b5 100644 --- a/wormhole-connect/src/store/transferInput.ts +++ b/wormhole-connect/src/store/transferInput.ts @@ -184,7 +184,14 @@ const performModificationsIfFromChainChanged = (state: TransferInputState) => { state.amount = ''; } } - if ( + if (isNttRoute(route) && destToken) { + const groupKey = getNttGroupKey(tokenConfig, config.tokens[destToken]); + if (groupKey) { + state.token = getNttTokenByGroupKey(groupKey, fromChain!)?.key || ''; + } else { + state.token = ''; + } + } else if ( tokenConfig.symbol === 'USDC' && tokenConfig.nativeChain !== fromChain ) { @@ -201,13 +208,6 @@ const performModificationsIfFromChainChanged = (state: TransferInputState) => { if (tokenConfig.nativeChain !== fromChain) { state.token = getNativeVersionOfToken(tokenConfig.symbol, fromChain!); } - } else if (isNttRoute(route) && destToken) { - const groupKey = getNttGroupKey(tokenConfig, config.tokens[destToken]); - if (groupKey) { - state.token = getNttTokenByGroupKey(groupKey, fromChain!)?.key || ''; - } else { - state.token = ''; - } } } }; @@ -220,7 +220,17 @@ const performModificationsIfToChainChanged = (state: TransferInputState) => { if (!toChain) { state.destToken = ''; } - if (tokenConfig.symbol === 'USDC' && tokenConfig.nativeChain !== toChain) { + if (isNttRoute(route) && token) { + const groupKey = getNttGroupKey(tokenConfig, config.tokens[token]); + if (groupKey) { + state.destToken = getNttTokenByGroupKey(groupKey, toChain!)?.key || ''; + } else { + state.destToken = ''; + } + } else if ( + tokenConfig.symbol === 'USDC' && + tokenConfig.nativeChain !== toChain + ) { state.destToken = getNativeVersionOfToken('USDC', toChain!); } else if ( tokenConfig.symbol === 'tBTC' && @@ -234,13 +244,6 @@ const performModificationsIfToChainChanged = (state: TransferInputState) => { if (tokenConfig.nativeChain !== toChain) { state.destToken = getNativeVersionOfToken(tokenConfig.symbol, toChain!); } - } else if (isNttRoute(route) && token) { - const groupKey = getNttGroupKey(tokenConfig, config.tokens[token]); - if (groupKey) { - state.destToken = getNttTokenByGroupKey(groupKey, toChain!)?.key || ''; - } else { - state.destToken = ''; - } } } }; From f4010f82f542e79df2a8beba3b89c7d1cb75b909 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Thu, 28 Mar 2024 19:58:37 -0500 Subject: [PATCH 07/17] custom ntt group support --- wormhole-connect/src/config/index.ts | 13 +++++-- wormhole-connect/src/config/types.ts | 3 ++ wormhole-connect/src/config/utils.ts | 51 +++++++++++++++++++++++++++- 3 files changed, 63 insertions(+), 4 deletions(-) diff --git a/wormhole-connect/src/config/index.ts b/wormhole-connect/src/config/index.ts index 07f3840b7..4f35f77ec 100644 --- a/wormhole-connect/src/config/index.ts +++ b/wormhole-connect/src/config/index.ts @@ -11,7 +11,11 @@ import TESTNET from './testnet'; import DEVNET from './devnet'; import type { WormholeConnectConfig } from './types'; import { Network, InternalConfig, Route, TokensConfig } from './types'; -import { mergeCustomTokensConfig, validateDefaults } from './utils'; +import { + mergeCustomTokensConfig, + mergeNttGroups, + validateDefaults, +} from './utils'; export function buildConfig( customConfig?: WormholeConnectConfig, @@ -134,8 +138,11 @@ export function buildConfig( wstETHBridgeMaxAmount: customConfig?.wstETHBridgeMaxAmount ?? 5, // NTT config - // TODO: allow custom NTT config. validate similar to custom tokens - nttGroups: networkData.nttGroups, + nttGroups: mergeNttGroups( + tokens, + networkData.nttGroups, + customConfig?.nttGroups, + ), }; } diff --git a/wormhole-connect/src/config/types.ts b/wormhole-connect/src/config/types.ts index d9de9742d..36e569309 100644 --- a/wormhole-connect/src/config/types.ts +++ b/wormhole-connect/src/config/types.ts @@ -123,6 +123,9 @@ export interface WormholeConnectConfig { // Route settings ethBridgeMaxAmount?: number; wstETHBridgeMaxAmount?: number; + + // NTT config + nttGroups?: NttGroups; } // This is the exported config value used throughout the code base diff --git a/wormhole-connect/src/config/utils.ts b/wormhole-connect/src/config/utils.ts index bec41c943..64904b41f 100644 --- a/wormhole-connect/src/config/utils.ts +++ b/wormhole-connect/src/config/utils.ts @@ -1,5 +1,6 @@ +import { isEqualCaseInsensitive } from 'utils'; import config from '.'; -import { BridgeDefaults, TokensConfig } from './types'; +import { BridgeDefaults, NttGroups, TokensConfig } from './types'; const error = (msg: string) => { console.error(`Wormhole Connect: ${msg}`); @@ -85,6 +86,54 @@ export const mergeCustomTokensConfig = ( return builtin; }; +export const mergeNttGroups = ( + tokens: TokensConfig, + builtin: NttGroups, + custom?: NttGroups, +) => { + if (!custom) return builtin; + console.log(custom); + + for (const key in custom) { + if (key in builtin) { + console.warn( + `Skipping custom NTT group config for "${key}" because it conflicts with a built-in`, + ); + continue; + } + + const customGroup = custom[key]; + // if any of the managers in the custom group exist in the built-in groups, skip + if ( + customGroup.nttManagers.some((manager) => + Object.values(builtin).some((group) => + group.nttManagers.some((builtinManager) => + isEqualCaseInsensitive(builtinManager.address, manager.address), + ), + ), + ) + ) { + console.warn( + `Skipping custom NTT group config for "${key}" because it conflicts with a built-in`, + ); + continue; + } + + // if any of the token keys in the custom group don't exist in the tokens config, skip + if (customGroup.nttManagers.some((manager) => !tokens[manager.tokenKey])) { + console.warn( + `Skipping custom NTT group config for "${key}" because it references a token that does not exist`, + ); + continue; + } + + console.info(`Accepted custom NTT group config for "${key}"`); + builtin[key] = custom[key]; + } + + return builtin; +}; + export const validateDefaults = (defaults: BridgeDefaults | undefined) => { if (!defaults) return; const { From 9e6508b2bb7953a242b9d172db66b48c51ed4004 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Fri, 29 Mar 2024 15:19:28 -0500 Subject: [PATCH 08/17] abi version support, added 0.1.0 abis --- wormhole-connect/src/config/utils.ts | 1 - .../ntt/chains/evm/abis/0.1.0/NttManager.ts | 1891 +++++++++++++++++ .../evm/abis/0.1.0/NttManager__factory.ts | 1853 ++++++++++++++++ .../evm/abis/0.1.0/WormholeTransceiver.ts | 1468 +++++++++++++ .../0.1.0/WormholeTransceiver__factory.ts | 1364 ++++++++++++ .../src/routes/ntt/chains/evm/abis/index.ts | 3 - .../evm/abis/{ => testnet}/NttManager.ts | 2 +- .../abis/{ => testnet}/NttManager__factory.ts | 0 .../abis/{ => testnet}/WormholeTransceiver.ts | 2 +- .../WormholeTransceiver__factory.ts | 0 .../src/routes/ntt/chains/evm/getMessage.ts | 10 +- .../src/routes/ntt/chains/evm/nttManager.ts | 186 +- .../ntt/chains/evm/wormholeTransceiver.ts | 81 +- wormhole-connect/src/routes/ntt/errors.ts | 7 + wormhole-connect/src/routes/ntt/nttBase.ts | 8 + wormhole-connect/src/views/Bridge/Send.tsx | 3 + wormhole-connect/src/views/Redeem/SendTo.tsx | 3 +- 17 files changed, 6794 insertions(+), 88 deletions(-) create mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager.ts create mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager__factory.ts create mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver.ts create mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver__factory.ts delete mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/index.ts rename wormhole-connect/src/routes/ntt/chains/evm/abis/{ => testnet}/NttManager.ts (99%) rename wormhole-connect/src/routes/ntt/chains/evm/abis/{ => testnet}/NttManager__factory.ts (100%) rename wormhole-connect/src/routes/ntt/chains/evm/abis/{ => testnet}/WormholeTransceiver.ts (99%) rename wormhole-connect/src/routes/ntt/chains/evm/abis/{ => testnet}/WormholeTransceiver__factory.ts (100%) diff --git a/wormhole-connect/src/config/utils.ts b/wormhole-connect/src/config/utils.ts index 64904b41f..bd7c57e57 100644 --- a/wormhole-connect/src/config/utils.ts +++ b/wormhole-connect/src/config/utils.ts @@ -92,7 +92,6 @@ export const mergeNttGroups = ( custom?: NttGroups, ) => { if (!custom) return builtin; - console.log(custom); for (const key in custom) { if (key in builtin) { diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager.ts new file mode 100644 index 000000000..2962c74c9 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager.ts @@ -0,0 +1,1891 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { + FunctionFragment, + Result, + EventFragment, +} from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from '../common'; + +export declare namespace TransceiverStructs { + export type NttManagerMessageStruct = { + id: BytesLike; + sender: BytesLike; + payload: BytesLike; + }; + + export type NttManagerMessageStructOutput = [string, string, string] & { + id: string; + sender: string; + payload: string; + }; +} + +export declare namespace IRateLimiter { + export type RateLimitParamsStruct = { + limit: BigNumberish; + currentCapacity: BigNumberish; + lastTxTimestamp: BigNumberish; + }; + + export type RateLimitParamsStructOutput = [ + BigNumber, + BigNumber, + BigNumber, + ] & { + limit: BigNumber; + currentCapacity: BigNumber; + lastTxTimestamp: BigNumber; + }; + + export type InboundQueuedTransferStruct = { + amount: BigNumberish; + txTimestamp: BigNumberish; + recipient: string; + }; + + export type InboundQueuedTransferStructOutput = [ + BigNumber, + BigNumber, + string, + ] & { amount: BigNumber; txTimestamp: BigNumber; recipient: string }; + + export type OutboundQueuedTransferStruct = { + recipient: BytesLike; + amount: BigNumberish; + txTimestamp: BigNumberish; + recipientChain: BigNumberish; + sender: string; + transceiverInstructions: BytesLike; + }; + + export type OutboundQueuedTransferStructOutput = [ + string, + BigNumber, + BigNumber, + number, + string, + string, + ] & { + recipient: string; + amount: BigNumber; + txTimestamp: BigNumber; + recipientChain: number; + sender: string; + transceiverInstructions: string; + }; +} + +export declare namespace INttManager { + export type NttManagerPeerStruct = { + peerAddress: BytesLike; + tokenDecimals: BigNumberish; + }; + + export type NttManagerPeerStructOutput = [string, number] & { + peerAddress: string; + tokenDecimals: number; + }; +} + +export interface NttManagerInterface extends utils.Interface { + functions: { + 'NTT_MANAGER_VERSION()': FunctionFragment; + 'attestationReceived(uint16,bytes32,(bytes32,bytes32,bytes))': FunctionFragment; + 'chainId()': FunctionFragment; + 'completeInboundQueuedTransfer(bytes32)': FunctionFragment; + 'completeOutboundQueuedTransfer(uint64)': FunctionFragment; + 'executeMsg(uint16,bytes32,(bytes32,bytes32,bytes))': FunctionFragment; + 'getCurrentInboundCapacity(uint16)': FunctionFragment; + 'getCurrentOutboundCapacity()': FunctionFragment; + 'getInboundLimitParams(uint16)': FunctionFragment; + 'getInboundQueuedTransfer(bytes32)': FunctionFragment; + 'getMigratesImmutables()': FunctionFragment; + 'getMode()': FunctionFragment; + 'getOutboundLimitParams()': FunctionFragment; + 'getOutboundQueuedTransfer(uint64)': FunctionFragment; + 'getPeer(uint16)': FunctionFragment; + 'getThreshold()': FunctionFragment; + 'getTransceivers()': FunctionFragment; + 'initialize()': FunctionFragment; + 'isMessageApproved(bytes32)': FunctionFragment; + 'isMessageExecuted(bytes32)': FunctionFragment; + 'isPaused()': FunctionFragment; + 'messageAttestations(bytes32)': FunctionFragment; + 'migrate()': FunctionFragment; + 'mode()': FunctionFragment; + 'nextMessageSequence()': FunctionFragment; + 'owner()': FunctionFragment; + 'pause()': FunctionFragment; + 'pauser()': FunctionFragment; + 'quoteDeliveryPrice(uint16,bytes)': FunctionFragment; + 'rateLimitDuration()': FunctionFragment; + 'removeTransceiver(address)': FunctionFragment; + 'setInboundLimit(uint256,uint16)': FunctionFragment; + 'setOutboundLimit(uint256)': FunctionFragment; + 'setPeer(uint16,bytes32,uint8,uint256)': FunctionFragment; + 'setThreshold(uint8)': FunctionFragment; + 'setTransceiver(address)': FunctionFragment; + 'token()': FunctionFragment; + 'tokenDecimals()': FunctionFragment; + 'transceiverAttestedToMessage(bytes32,uint8)': FunctionFragment; + 'transfer(uint256,uint16,bytes32)': FunctionFragment; + 'transfer(uint256,uint16,bytes32,bool,bytes)': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'transferPauserCapability(address)': FunctionFragment; + 'unpause()': FunctionFragment; + 'upgrade(address)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'NTT_MANAGER_VERSION' + | 'attestationReceived' + | 'chainId' + | 'completeInboundQueuedTransfer' + | 'completeOutboundQueuedTransfer' + | 'executeMsg' + | 'getCurrentInboundCapacity' + | 'getCurrentOutboundCapacity' + | 'getInboundLimitParams' + | 'getInboundQueuedTransfer' + | 'getMigratesImmutables' + | 'getMode' + | 'getOutboundLimitParams' + | 'getOutboundQueuedTransfer' + | 'getPeer' + | 'getThreshold' + | 'getTransceivers' + | 'initialize' + | 'isMessageApproved' + | 'isMessageExecuted' + | 'isPaused' + | 'messageAttestations' + | 'migrate' + | 'mode' + | 'nextMessageSequence' + | 'owner' + | 'pause' + | 'pauser' + | 'quoteDeliveryPrice' + | 'rateLimitDuration' + | 'removeTransceiver' + | 'setInboundLimit' + | 'setOutboundLimit' + | 'setPeer' + | 'setThreshold' + | 'setTransceiver' + | 'token' + | 'tokenDecimals' + | 'transceiverAttestedToMessage' + | 'transfer(uint256,uint16,bytes32)' + | 'transfer(uint256,uint16,bytes32,bool,bytes)' + | 'transferOwnership' + | 'transferPauserCapability' + | 'unpause' + | 'upgrade', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'NTT_MANAGER_VERSION', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'attestationReceived', + values: [ + BigNumberish, + BytesLike, + TransceiverStructs.NttManagerMessageStruct, + ], + ): string; + encodeFunctionData(functionFragment: 'chainId', values?: undefined): string; + encodeFunctionData( + functionFragment: 'completeInboundQueuedTransfer', + values: [BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'completeOutboundQueuedTransfer', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'executeMsg', + values: [ + BigNumberish, + BytesLike, + TransceiverStructs.NttManagerMessageStruct, + ], + ): 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?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getTransceivers', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'initialize', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'isMessageApproved', + values: [BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'isMessageExecuted', + values: [BytesLike], + ): string; + encodeFunctionData(functionFragment: 'isPaused', values?: undefined): string; + encodeFunctionData( + functionFragment: 'messageAttestations', + values: [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: 'removeTransceiver', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'setInboundLimit', + values: [BigNumberish, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setOutboundLimit', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setPeer', + values: [BigNumberish, BytesLike, BigNumberish, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setThreshold', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setTransceiver', + values: [string], + ): string; + encodeFunctionData(functionFragment: 'token', values?: undefined): string; + encodeFunctionData( + functionFragment: 'tokenDecimals', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'transceiverAttestedToMessage', + values: [BytesLike, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'transfer(uint256,uint16,bytes32)', + values: [BigNumberish, BigNumberish, BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'transfer(uint256,uint16,bytes32,bool,bytes)', + values: [BigNumberish, BigNumberish, BytesLike, boolean, BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'transferOwnership', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'transferPauserCapability', + values: [string], + ): string; + encodeFunctionData(functionFragment: 'unpause', values?: undefined): string; + encodeFunctionData(functionFragment: 'upgrade', values: [string]): string; + + decodeFunctionResult( + functionFragment: 'NTT_MANAGER_VERSION', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'attestationReceived', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'chainId', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'completeInboundQueuedTransfer', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'completeOutboundQueuedTransfer', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'executeMsg', 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: 'getTransceivers', + 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: 'removeTransceiver', + 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)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transfer(uint256,uint16,bytes32,bool,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; + + events: { + 'AdminChanged(address,address)': EventFragment; + 'BeaconUpgraded(address)': EventFragment; + 'InboundTransferQueued(bytes32)': EventFragment; + 'Initialized(uint64)': EventFragment; + 'MessageAlreadyExecuted(bytes32,bytes32)': EventFragment; + 'MessageAttestedTo(bytes32,address,uint8)': EventFragment; + 'NotPaused(bool)': EventFragment; + 'OutboundTransferQueued(uint64)': EventFragment; + 'OutboundTransferRateLimited(address,uint64,uint256,uint256)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'Paused(bool)': EventFragment; + 'PauserTransferred(address,address)': EventFragment; + 'PeerUpdated(uint16,bytes32,uint8,bytes32,uint8)': EventFragment; + 'ThresholdChanged(uint8,uint8)': EventFragment; + 'TransceiverAdded(address,uint256,uint8)': EventFragment; + 'TransceiverRemoved(address,uint8)': EventFragment; + 'TransferRedeemed(bytes32)': EventFragment; + 'TransferSent(bytes32,uint256,uint256,uint16,uint64)': EventFragment; + 'Upgraded(address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'AdminChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'BeaconUpgraded'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'InboundTransferQueued'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'MessageAlreadyExecuted'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'MessageAttestedTo'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'NotPaused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OutboundTransferQueued'): EventFragment; + getEvent( + nameOrSignatureOrTopic: 'OutboundTransferRateLimited', + ): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'PauserTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'PeerUpdated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ThresholdChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransceiverAdded'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransceiverRemoved'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransferRedeemed'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransferSent'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Upgraded'): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface InboundTransferQueuedEventObject { + digest: string; +} +export type InboundTransferQueuedEvent = TypedEvent< + [string], + InboundTransferQueuedEventObject +>; + +export type InboundTransferQueuedEventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: BigNumber; +} +export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface MessageAlreadyExecutedEventObject { + sourceNttManager: string; + msgHash: string; +} +export type MessageAlreadyExecutedEvent = TypedEvent< + [string, string], + MessageAlreadyExecutedEventObject +>; + +export type MessageAlreadyExecutedEventFilter = + TypedEventFilter; + +export interface MessageAttestedToEventObject { + digest: string; + transceiver: string; + index: number; +} +export type MessageAttestedToEvent = TypedEvent< + [string, string, number], + MessageAttestedToEventObject +>; + +export type MessageAttestedToEventFilter = + TypedEventFilter; + +export interface NotPausedEventObject { + notPaused: boolean; +} +export type NotPausedEvent = TypedEvent<[boolean], NotPausedEventObject>; + +export type NotPausedEventFilter = TypedEventFilter; + +export interface OutboundTransferQueuedEventObject { + queueSequence: BigNumber; +} +export type OutboundTransferQueuedEvent = TypedEvent< + [BigNumber], + OutboundTransferQueuedEventObject +>; + +export type OutboundTransferQueuedEventFilter = + TypedEventFilter; + +export interface OutboundTransferRateLimitedEventObject { + sender: string; + sequence: BigNumber; + amount: BigNumber; + currentCapacity: BigNumber; +} +export type OutboundTransferRateLimitedEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber], + OutboundTransferRateLimitedEventObject +>; + +export type OutboundTransferRateLimitedEventFilter = + TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface PausedEventObject { + paused: boolean; +} +export type PausedEvent = TypedEvent<[boolean], PausedEventObject>; + +export type PausedEventFilter = TypedEventFilter; + +export interface PauserTransferredEventObject { + oldPauser: string; + newPauser: string; +} +export type PauserTransferredEvent = TypedEvent< + [string, string], + PauserTransferredEventObject +>; + +export type PauserTransferredEventFilter = + TypedEventFilter; + +export interface PeerUpdatedEventObject { + chainId_: number; + oldPeerContract: string; + oldPeerDecimals: number; + peerContract: string; + peerDecimals: number; +} +export type PeerUpdatedEvent = TypedEvent< + [number, string, number, string, number], + PeerUpdatedEventObject +>; + +export type PeerUpdatedEventFilter = TypedEventFilter; + +export interface ThresholdChangedEventObject { + oldThreshold: number; + threshold: number; +} +export type ThresholdChangedEvent = TypedEvent< + [number, number], + ThresholdChangedEventObject +>; + +export type ThresholdChangedEventFilter = + TypedEventFilter; + +export interface TransceiverAddedEventObject { + transceiver: string; + transceiversNum: BigNumber; + threshold: number; +} +export type TransceiverAddedEvent = TypedEvent< + [string, BigNumber, number], + TransceiverAddedEventObject +>; + +export type TransceiverAddedEventFilter = + TypedEventFilter; + +export interface TransceiverRemovedEventObject { + transceiver: string; + threshold: number; +} +export type TransceiverRemovedEvent = TypedEvent< + [string, number], + TransceiverRemovedEventObject +>; + +export type TransceiverRemovedEventFilter = + TypedEventFilter; + +export interface TransferRedeemedEventObject { + digest: string; +} +export type TransferRedeemedEvent = TypedEvent< + [string], + TransferRedeemedEventObject +>; + +export type TransferRedeemedEventFilter = + TypedEventFilter; + +export interface TransferSentEventObject { + recipient: string; + amount: BigNumber; + fee: BigNumber; + recipientChain: number; + msgSequence: BigNumber; +} +export type TransferSentEvent = TypedEvent< + [string, BigNumber, BigNumber, number, BigNumber], + TransferSentEventObject +>; + +export type TransferSentEventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface NttManager extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: NttManagerInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined, + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter, + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter, + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + NTT_MANAGER_VERSION(overrides?: CallOverrides): Promise<[string]>; + + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + chainId(overrides?: CallOverrides): Promise<[number]>; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + getCurrentOutboundCapacity(overrides?: CallOverrides): Promise<[BigNumber]>; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise<[IRateLimiter.RateLimitParamsStructOutput]>; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise<[IRateLimiter.InboundQueuedTransferStructOutput]>; + + getMigratesImmutables(overrides?: CallOverrides): Promise<[boolean]>; + + getMode(overrides?: CallOverrides): Promise<[number]>; + + getOutboundLimitParams( + overrides?: CallOverrides, + ): Promise<[IRateLimiter.RateLimitParamsStructOutput]>; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise<[IRateLimiter.OutboundQueuedTransferStructOutput]>; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise<[INttManager.NttManagerPeerStructOutput]>; + + getThreshold(overrides?: CallOverrides): Promise<[number]>; + + getTransceivers( + overrides?: CallOverrides, + ): Promise<[string[]] & { result: string[] }>; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isPaused(overrides?: CallOverrides): Promise<[boolean]>; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise<[number] & { count: number }>; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + mode(overrides?: CallOverrides): Promise<[number]>; + + nextMessageSequence(overrides?: CallOverrides): Promise<[BigNumber]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + pauser(overrides?: CallOverrides): Promise<[string]>; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: BytesLike, + overrides?: CallOverrides, + ): Promise<[BigNumber[], BigNumber]>; + + rateLimitDuration(overrides?: CallOverrides): Promise<[BigNumber]>; + + removeTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + token(overrides?: CallOverrides): Promise<[string]>; + + tokenDecimals(overrides?: CallOverrides): Promise<[number]>; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; + + NTT_MANAGER_VERSION(overrides?: CallOverrides): Promise; + + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + chainId(overrides?: CallOverrides): Promise; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getMode(overrides?: CallOverrides): Promise; + + getOutboundLimitParams( + overrides?: CallOverrides, + ): Promise; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getThreshold(overrides?: CallOverrides): Promise; + + getTransceivers(overrides?: CallOverrides): Promise; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + mode(overrides?: CallOverrides): Promise; + + nextMessageSequence(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: BytesLike, + overrides?: CallOverrides, + ): Promise<[BigNumber[], BigNumber]>; + + rateLimitDuration(overrides?: CallOverrides): Promise; + + removeTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + token(overrides?: CallOverrides): Promise; + + tokenDecimals(overrides?: CallOverrides): Promise; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + callStatic: { + NTT_MANAGER_VERSION(overrides?: CallOverrides): Promise; + + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: CallOverrides, + ): Promise; + + chainId(overrides?: CallOverrides): Promise; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: CallOverrides, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getMode(overrides?: CallOverrides): Promise; + + getOutboundLimitParams( + overrides?: CallOverrides, + ): Promise; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getThreshold(overrides?: CallOverrides): Promise; + + getTransceivers(overrides?: CallOverrides): Promise; + + initialize(overrides?: CallOverrides): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + migrate(overrides?: CallOverrides): Promise; + + mode(overrides?: CallOverrides): Promise; + + nextMessageSequence(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: CallOverrides): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: BytesLike, + overrides?: CallOverrides, + ): Promise<[BigNumber[], BigNumber]>; + + rateLimitDuration(overrides?: CallOverrides): Promise; + + removeTransceiver( + transceiver: string, + overrides?: CallOverrides, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: CallOverrides, + ): Promise; + + token(overrides?: CallOverrides): Promise; + + tokenDecimals(overrides?: CallOverrides): Promise; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: CallOverrides, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: CallOverrides, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: CallOverrides, + ): Promise; + + unpause(overrides?: CallOverrides): Promise; + + upgrade( + newImplementation: string, + overrides?: CallOverrides, + ): Promise; + }; + + filters: { + 'AdminChanged(address,address)'( + previousAdmin?: null, + newAdmin?: null, + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null, + ): AdminChangedEventFilter; + + 'BeaconUpgraded(address)'( + beacon?: string | null, + ): BeaconUpgradedEventFilter; + BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter; + + 'InboundTransferQueued(bytes32)'( + digest?: null, + ): InboundTransferQueuedEventFilter; + InboundTransferQueued(digest?: null): InboundTransferQueuedEventFilter; + + 'Initialized(uint64)'(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + 'MessageAlreadyExecuted(bytes32,bytes32)'( + sourceNttManager?: BytesLike | null, + msgHash?: BytesLike | null, + ): MessageAlreadyExecutedEventFilter; + MessageAlreadyExecuted( + sourceNttManager?: BytesLike | null, + msgHash?: BytesLike | null, + ): MessageAlreadyExecutedEventFilter; + + 'MessageAttestedTo(bytes32,address,uint8)'( + digest?: null, + transceiver?: null, + index?: null, + ): MessageAttestedToEventFilter; + MessageAttestedTo( + digest?: null, + transceiver?: null, + index?: null, + ): MessageAttestedToEventFilter; + + 'NotPaused(bool)'(notPaused?: null): NotPausedEventFilter; + NotPaused(notPaused?: null): NotPausedEventFilter; + + 'OutboundTransferQueued(uint64)'( + queueSequence?: null, + ): OutboundTransferQueuedEventFilter; + OutboundTransferQueued( + queueSequence?: null, + ): OutboundTransferQueuedEventFilter; + + 'OutboundTransferRateLimited(address,uint64,uint256,uint256)'( + sender?: string | null, + sequence?: null, + amount?: null, + currentCapacity?: null, + ): OutboundTransferRateLimitedEventFilter; + OutboundTransferRateLimited( + sender?: string | null, + sequence?: null, + amount?: null, + currentCapacity?: null, + ): OutboundTransferRateLimitedEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + + 'Paused(bool)'(paused?: null): PausedEventFilter; + Paused(paused?: null): PausedEventFilter; + + 'PauserTransferred(address,address)'( + oldPauser?: string | null, + newPauser?: string | null, + ): PauserTransferredEventFilter; + PauserTransferred( + oldPauser?: string | null, + newPauser?: string | null, + ): PauserTransferredEventFilter; + + 'PeerUpdated(uint16,bytes32,uint8,bytes32,uint8)'( + chainId_?: BigNumberish | null, + oldPeerContract?: null, + oldPeerDecimals?: null, + peerContract?: null, + peerDecimals?: null, + ): PeerUpdatedEventFilter; + PeerUpdated( + chainId_?: BigNumberish | null, + oldPeerContract?: null, + oldPeerDecimals?: null, + peerContract?: null, + peerDecimals?: null, + ): PeerUpdatedEventFilter; + + 'ThresholdChanged(uint8,uint8)'( + oldThreshold?: null, + threshold?: null, + ): ThresholdChangedEventFilter; + ThresholdChanged( + oldThreshold?: null, + threshold?: null, + ): ThresholdChangedEventFilter; + + 'TransceiverAdded(address,uint256,uint8)'( + transceiver?: null, + transceiversNum?: null, + threshold?: null, + ): TransceiverAddedEventFilter; + TransceiverAdded( + transceiver?: null, + transceiversNum?: null, + threshold?: null, + ): TransceiverAddedEventFilter; + + 'TransceiverRemoved(address,uint8)'( + transceiver?: null, + threshold?: null, + ): TransceiverRemovedEventFilter; + TransceiverRemoved( + transceiver?: null, + threshold?: null, + ): TransceiverRemovedEventFilter; + + 'TransferRedeemed(bytes32)'( + digest?: BytesLike | null, + ): TransferRedeemedEventFilter; + TransferRedeemed(digest?: BytesLike | null): TransferRedeemedEventFilter; + + 'TransferSent(bytes32,uint256,uint256,uint16,uint64)'( + recipient?: null, + amount?: null, + fee?: null, + recipientChain?: null, + msgSequence?: null, + ): TransferSentEventFilter; + TransferSent( + recipient?: null, + amount?: null, + fee?: null, + recipientChain?: null, + msgSequence?: null, + ): TransferSentEventFilter; + + 'Upgraded(address)'(implementation?: string | null): UpgradedEventFilter; + Upgraded(implementation?: string | null): UpgradedEventFilter; + }; + + estimateGas: { + NTT_MANAGER_VERSION(overrides?: CallOverrides): Promise; + + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + chainId(overrides?: CallOverrides): Promise; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getMode(overrides?: CallOverrides): Promise; + + getOutboundLimitParams(overrides?: CallOverrides): Promise; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getThreshold(overrides?: CallOverrides): Promise; + + getTransceivers(overrides?: CallOverrides): Promise; + + initialize(overrides?: Overrides & { from?: string }): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + migrate(overrides?: Overrides & { from?: string }): Promise; + + mode(overrides?: CallOverrides): Promise; + + nextMessageSequence(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: string }): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: BytesLike, + overrides?: CallOverrides, + ): Promise; + + rateLimitDuration(overrides?: CallOverrides): Promise; + + removeTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + token(overrides?: CallOverrides): Promise; + + tokenDecimals(overrides?: CallOverrides): Promise; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause(overrides?: Overrides & { from?: string }): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; + + populateTransaction: { + NTT_MANAGER_VERSION( + overrides?: CallOverrides, + ): Promise; + + attestationReceived( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + payload: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + chainId(overrides?: CallOverrides): Promise; + + completeInboundQueuedTransfer( + digest: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + completeOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + executeMsg( + sourceChainId: BigNumberish, + sourceNttManagerAddress: BytesLike, + message: TransceiverStructs.NttManagerMessageStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCurrentInboundCapacity( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getCurrentOutboundCapacity( + overrides?: CallOverrides, + ): Promise; + + getInboundLimitParams( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getInboundQueuedTransfer( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + getMigratesImmutables( + overrides?: CallOverrides, + ): Promise; + + getMode(overrides?: CallOverrides): Promise; + + getOutboundLimitParams( + overrides?: CallOverrides, + ): Promise; + + getOutboundQueuedTransfer( + queueSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getPeer( + chainId_: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + getThreshold(overrides?: CallOverrides): Promise; + + getTransceivers(overrides?: CallOverrides): Promise; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isMessageApproved( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isMessageExecuted( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + messageAttestations( + digest: BytesLike, + overrides?: CallOverrides, + ): Promise; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + mode(overrides?: CallOverrides): Promise; + + nextMessageSequence( + overrides?: CallOverrides, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + recipientChain: BigNumberish, + transceiverInstructions: BytesLike, + overrides?: CallOverrides, + ): Promise; + + rateLimitDuration(overrides?: CallOverrides): Promise; + + removeTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setInboundLimit( + limit: BigNumberish, + chainId_: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setOutboundLimit( + limit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setPeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + decimals: BigNumberish, + inboundLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setThreshold( + threshold: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setTransceiver( + transceiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + token(overrides?: CallOverrides): Promise; + + tokenDecimals(overrides?: CallOverrides): Promise; + + transceiverAttestedToMessage( + digest: BytesLike, + index: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + 'transfer(uint256,uint16,bytes32)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + 'transfer(uint256,uint16,bytes32,bool,bytes)'( + amount: BigNumberish, + recipientChain: BigNumberish, + recipient: BytesLike, + shouldQueue: boolean, + transceiverInstructions: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; +} diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager__factory.ts new file mode 100644 index 000000000..3c3cf5f9a --- /dev/null +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager__factory.ts @@ -0,0 +1,1853 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { + Signer, + utils, + Contract, + ContractFactory, + BigNumberish, + Overrides, +} from 'ethers'; +import type { Provider, TransactionRequest } from '@ethersproject/providers'; +import type { NttManager, NttManagerInterface } from './NttManager'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'enum IManagerBase.Mode', + name: '_mode', + type: 'uint8', + }, + { + internalType: 'uint16', + name: '_chainId', + type: 'uint16', + }, + { + internalType: 'uint64', + name: '_rateLimitDuration', + type: 'uint64', + }, + { + internalType: 'bool', + name: '_skipRateLimiting', + type: 'bool', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'burnAmount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'balanceDiff', + type: 'uint256', + }, + ], + name: 'BurnAmountDifferentThanBalanceDiff', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'caller', + type: 'address', + }, + ], + name: 'CallerNotTransceiver', + type: 'error', + }, + { + inputs: [ + { + internalType: 'TrimmedAmount', + name: 'newCurrentCapacity', + type: 'uint72', + }, + { + internalType: 'TrimmedAmount', + name: 'newLimit', + type: 'uint72', + }, + ], + name: 'CapacityCannotExceedLimit', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'requiredPayment', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'providedPayment', + type: 'uint256', + }, + ], + name: 'DeliveryPaymentTooLow', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'DisabledTransceiver', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'InboundQueuedTransferNotFound', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + internalType: 'uint256', + name: 'transferTimestamp', + type: 'uint256', + }, + ], + name: 'InboundQueuedTransferStillQueued', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'evmChainId', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'blockChainId', + type: 'uint256', + }, + ], + name: 'InvalidFork', + type: 'error', + }, + { + inputs: [], + name: 'InvalidInitialization', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint8', + name: 'mode', + type: 'uint8', + }, + ], + name: 'InvalidMode', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'InvalidPauser', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerAddress', + type: 'bytes32', + }, + ], + name: 'InvalidPeer', + type: 'error', + }, + { + inputs: [], + name: 'InvalidPeerChainIdZero', + type: 'error', + }, + { + inputs: [], + name: 'InvalidPeerDecimals', + type: 'error', + }, + { + inputs: [], + name: 'InvalidPeerZeroAddress', + type: 'error', + }, + { + inputs: [], + name: 'InvalidRecipient', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'targetChain', + type: 'uint16', + }, + { + internalType: 'uint16', + name: 'thisChain', + type: 'uint16', + }, + ], + name: 'InvalidTargetChain', + type: 'error', + }, + { + inputs: [], + name: 'InvalidTransceiverZeroAddress', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'msgHash', + type: 'bytes32', + }, + ], + name: 'MessageNotApproved', + type: 'error', + }, + { + inputs: [], + name: 'NoEnabledTransceivers', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'NonRegisteredTransceiver', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: '', + type: 'bytes32', + }, + ], + name: 'NotAnEvmAddress', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'currentCapacity', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'NotEnoughCapacity', + type: 'error', + }, + { + inputs: [], + name: 'NotInitializing', + type: 'error', + }, + { + inputs: [], + name: 'NotMigrating', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint8', + name: 'decimals', + type: 'uint8', + }, + { + internalType: 'uint8', + name: 'decimalsOther', + type: 'uint8', + }, + ], + name: 'NumberOfDecimalsNotEqual', + type: 'error', + }, + { + inputs: [], + name: 'OnlyDelegateCall', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint64', + name: 'queueSequence', + type: 'uint64', + }, + ], + name: 'OutboundQueuedTransferNotFound', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint64', + name: 'queueSequence', + type: 'uint64', + }, + { + internalType: 'uint256', + name: 'transferTimestamp', + type: 'uint256', + }, + ], + name: 'OutboundQueuedTransferStillQueued', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'OwnableInvalidOwner', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'OwnableUnauthorizedAccount', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'PeerNotRegistered', + type: 'error', + }, + { + inputs: [], + name: 'ReentrancyGuardReentrantCall', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'refundAmount', + type: 'uint256', + }, + ], + name: 'RefundFailed', + type: 'error', + }, + { + inputs: [], + name: 'RequireContractIsNotPaused', + type: 'error', + }, + { + inputs: [], + name: 'RequireContractIsPaused', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'retrieved', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'registered', + type: 'uint256', + }, + ], + name: 'RetrievedIncorrectRegisteredTransceivers', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'threshold', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'transceivers', + type: 'uint256', + }, + ], + name: 'ThresholdTooHigh', + type: 'error', + }, + { + inputs: [], + name: 'TooManyTransceivers', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'nttManagerMessageHash', + type: 'bytes32', + }, + ], + name: 'TransceiverAlreadyAttestedToMessage', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'TransceiverAlreadyEnabled', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'dust', + type: 'uint256', + }, + ], + name: 'TransferAmountHasDust', + type: 'error', + }, + { + inputs: [], + name: 'UndefinedRateLimiting', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'expectedOwner', + type: 'address', + }, + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'UnexpectedDeployer', + type: 'error', + }, + { + inputs: [], + name: 'ZeroAmount', + type: 'error', + }, + { + inputs: [], + name: 'ZeroThreshold', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'previousAdmin', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'newAdmin', + type: 'address', + }, + ], + name: 'AdminChanged', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'beacon', + type: 'address', + }, + ], + name: 'BeaconUpgraded', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'InboundTransferQueued', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint64', + name: 'version', + type: 'uint64', + }, + ], + name: 'Initialized', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'bytes32', + name: 'sourceNttManager', + type: 'bytes32', + }, + { + indexed: true, + internalType: 'bytes32', + name: 'msgHash', + type: 'bytes32', + }, + ], + name: 'MessageAlreadyExecuted', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + { + indexed: false, + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + ], + name: 'MessageAttestedTo', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bool', + name: 'notPaused', + type: 'bool', + }, + ], + name: 'NotPaused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint64', + name: 'queueSequence', + type: 'uint64', + }, + ], + name: 'OutboundTransferQueued', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'sender', + type: 'address', + }, + { + indexed: false, + internalType: 'uint64', + name: 'sequence', + type: 'uint64', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'currentCapacity', + type: 'uint256', + }, + ], + name: 'OutboundTransferRateLimited', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'previousOwner', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnershipTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bool', + name: 'paused', + type: 'bool', + }, + ], + name: 'Paused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'oldPauser', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newPauser', + type: 'address', + }, + ], + name: 'PauserTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'oldPeerContract', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint8', + name: 'oldPeerDecimals', + type: 'uint8', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'peerContract', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint8', + name: 'peerDecimals', + type: 'uint8', + }, + ], + name: 'PeerUpdated', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint8', + name: 'oldThreshold', + type: 'uint8', + }, + { + indexed: false, + internalType: 'uint8', + name: 'threshold', + type: 'uint8', + }, + ], + name: 'ThresholdChanged', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'transceiversNum', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint8', + name: 'threshold', + type: 'uint8', + }, + ], + name: 'TransceiverAdded', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + { + indexed: false, + internalType: 'uint8', + name: 'threshold', + type: 'uint8', + }, + ], + name: 'TransceiverRemoved', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'TransferRedeemed', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'recipient', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'fee', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + indexed: false, + internalType: 'uint64', + name: 'msgSequence', + type: 'uint64', + }, + ], + name: 'TransferSent', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'implementation', + type: 'address', + }, + ], + name: 'Upgraded', + type: 'event', + }, + { + inputs: [], + name: 'NTT_MANAGER_VERSION', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'sourceChainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'sourceNttManagerAddress', + type: 'bytes32', + }, + { + components: [ + { + internalType: 'bytes32', + name: 'id', + type: 'bytes32', + }, + { + internalType: 'bytes32', + name: 'sender', + type: 'bytes32', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.NttManagerMessage', + name: 'payload', + type: 'tuple', + }, + ], + name: 'attestationReceived', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'chainId', + outputs: [ + { + internalType: 'uint16', + name: '', + type: 'uint16', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'completeInboundQueuedTransfer', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint64', + name: 'messageSequence', + type: 'uint64', + }, + ], + name: 'completeOutboundQueuedTransfer', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'sourceChainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'sourceNttManagerAddress', + type: 'bytes32', + }, + { + components: [ + { + internalType: 'bytes32', + name: 'id', + type: 'bytes32', + }, + { + internalType: 'bytes32', + name: 'sender', + type: 'bytes32', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.NttManagerMessage', + name: 'message', + type: 'tuple', + }, + ], + name: 'executeMsg', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + ], + name: 'getCurrentInboundCapacity', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getCurrentOutboundCapacity', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + ], + name: 'getInboundLimitParams', + outputs: [ + { + components: [ + { + internalType: 'TrimmedAmount', + name: 'limit', + type: 'uint72', + }, + { + internalType: 'TrimmedAmount', + name: 'currentCapacity', + type: 'uint72', + }, + { + internalType: 'uint64', + name: 'lastTxTimestamp', + type: 'uint64', + }, + ], + internalType: 'struct IRateLimiter.RateLimitParams', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'getInboundQueuedTransfer', + outputs: [ + { + components: [ + { + internalType: 'TrimmedAmount', + name: 'amount', + type: 'uint72', + }, + { + internalType: 'uint64', + name: 'txTimestamp', + type: 'uint64', + }, + { + internalType: 'address', + name: 'recipient', + type: 'address', + }, + ], + internalType: 'struct IRateLimiter.InboundQueuedTransfer', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getMigratesImmutables', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getMode', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getOutboundLimitParams', + outputs: [ + { + components: [ + { + internalType: 'TrimmedAmount', + name: 'limit', + type: 'uint72', + }, + { + internalType: 'TrimmedAmount', + name: 'currentCapacity', + type: 'uint72', + }, + { + internalType: 'uint64', + name: 'lastTxTimestamp', + type: 'uint64', + }, + ], + internalType: 'struct IRateLimiter.RateLimitParams', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint64', + name: 'queueSequence', + type: 'uint64', + }, + ], + name: 'getOutboundQueuedTransfer', + outputs: [ + { + components: [ + { + internalType: 'bytes32', + name: 'recipient', + type: 'bytes32', + }, + { + internalType: 'TrimmedAmount', + name: 'amount', + type: 'uint72', + }, + { + internalType: 'uint64', + name: 'txTimestamp', + type: 'uint64', + }, + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + internalType: 'address', + name: 'sender', + type: 'address', + }, + { + internalType: 'bytes', + name: 'transceiverInstructions', + type: 'bytes', + }, + ], + internalType: 'struct IRateLimiter.OutboundQueuedTransfer', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + ], + name: 'getPeer', + outputs: [ + { + components: [ + { + internalType: 'bytes32', + name: 'peerAddress', + type: 'bytes32', + }, + { + internalType: 'uint8', + name: 'tokenDecimals', + type: 'uint8', + }, + ], + internalType: 'struct INttManager.NttManagerPeer', + name: '', + type: 'tuple', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getThreshold', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getTransceivers', + outputs: [ + { + internalType: 'address[]', + name: 'result', + type: 'address[]', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [], + name: 'initialize', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'isMessageApproved', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'isMessageExecuted', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'isPaused', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + ], + name: 'messageAttestations', + outputs: [ + { + internalType: 'uint8', + name: 'count', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'migrate', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'mode', + outputs: [ + { + internalType: 'enum IManagerBase.Mode', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'nextMessageSequence', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'pause', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'pauser', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + internalType: 'bytes', + name: 'transceiverInstructions', + type: 'bytes', + }, + ], + name: 'quoteDeliveryPrice', + outputs: [ + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'rateLimitDuration', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'removeTransceiver', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'limit', + type: 'uint256', + }, + { + internalType: 'uint16', + name: 'chainId_', + type: 'uint16', + }, + ], + name: 'setInboundLimit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'limit', + type: 'uint256', + }, + ], + name: 'setOutboundLimit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'peerChainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerContract', + type: 'bytes32', + }, + { + internalType: 'uint8', + name: 'decimals', + type: 'uint8', + }, + { + internalType: 'uint256', + name: 'inboundLimit', + type: 'uint256', + }, + ], + name: 'setPeer', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint8', + name: 'threshold', + type: 'uint8', + }, + ], + name: 'setThreshold', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'transceiver', + type: 'address', + }, + ], + name: 'setTransceiver', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'token', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'tokenDecimals', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + ], + name: 'transceiverAttestedToMessage', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'recipient', + type: 'bytes32', + }, + ], + name: 'transfer', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'recipient', + type: 'bytes32', + }, + { + internalType: 'bool', + name: 'shouldQueue', + type: 'bool', + }, + { + internalType: 'bytes', + name: 'transceiverInstructions', + type: 'bytes', + }, + ], + name: 'transfer', + outputs: [ + { + internalType: 'uint64', + name: '', + type: 'uint64', + }, + ], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newPauser', + type: 'address', + }, + ], + name: 'transferPauserCapability', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'unpause', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newImplementation', + type: 'address', + }, + ], + name: 'upgrade', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, +] as const; + +const _bytecode = + '0x6101606040523480156200001257600080fd5b5060405162006a4838038062006a488339810160408190526200003591620005a6565b84848484846001600160401b03821615801562000050575080155b806200006d57506001600160401b038216158015906200006d5750805b156200008c5760405163e543ef0560e01b815260040160405180910390fd5b506001600160401b0316608052620000a36200010d565b620000ad62000279565b3060a0526001600160a01b03831660c052816001811115620000d357620000d362000640565b610100816001811115620000eb57620000eb62000640565b90525061ffff16610120525050466101405250503360e05250620006e0915050565b6000620001196200032d565b905060006200012762000363565b82548154919250610100900460ff1690811462000148576200014862000656565b60005b818110156200019d57620001888382815481106200016d576200016d6200066c565b6000918252602090912001546001600160a01b031662000392565b80620001948162000698565b9150506200014b565b5060005b8181101562000259576000620001b9826001620006b4565b90505b828110156200024357838181548110620001da57620001da6200066c565b60009182526020909120015484546001600160a01b03909116908590849081106200020957620002096200066c565b6000918252602090912001546001600160a01b0316036200022e576200022e62000656565b806200023a8162000698565b915050620001bc565b5080620002508162000698565b915050620001a1565b508254604060ff909116111562000274576200027462000656565b505050565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00805468010000000000000000900460ff1615620002ca5760405163f92ee8a960e01b815260040160405180910390fd5b80546001600160401b03908116146200032a5780546001600160401b0319166001600160401b0390811782556040519081527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b50565b6000806200035d60017f8561949d1c6242cee5c5a5aeb6b9c190ee611d7742fcec65d9e5b1341ea04d8a620006ca565b92915050565b6000806200035d60017e758a264b9bdbe3295fe36bd6ff7abaa122f48bf70e90af04a1b8a32d21e4e2620006ca565b60006200039e62000530565b90506000620003ac62000560565b90506000620003ba6200032d565b90506000620003c862000363565b6001600160a01b038616600090815260208681526040918290208251606081018452905460ff80821615158084526101008304821615159484019490945262010000909104169281019290925291925090806200043857508060200151158015620004385750604081015160ff16155b62000447576200044762000656565b604081015184546020830151600160ff9093169290921b166001600160401b03161515906000805b8654610100900460ff16811015620004da57896001600160a01b0316868281548110620004a057620004a06200066c565b6000918252602090912001546001600160a01b031603620004c55760019150620004da565b80620004d18162000698565b9150506200046f565b5081151583151514620004f157620004f162000656565b8115158115151462000507576200050762000656565b8554604085015160ff91821691161062000525576200052562000656565b505050505050505050565b6000806200035d60017f49bca747e973430e858f2f5de357b8dba36ea6d375b81bdb5d53dfaabf0b3a80620006ca565b6000806200035d60017ffd6568c039679b3b7cc93c26c41d9379b7b1bec1677120493b467688302cb120620006ca565b80518015158114620005a157600080fd5b919050565b600080600080600060a08688031215620005bf57600080fd5b85516001600160a01b0381168114620005d757600080fd5b602087015190955060028110620005ed57600080fd5b604087015190945061ffff811681146200060657600080fd5b60608701519093506001600160401b03811681146200062457600080fd5b9150620006346080870162000590565b90509295509295909350565b634e487b7160e01b600052602160045260246000fd5b634e487b7160e01b600052600160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b600060018201620006ad57620006ad62000682565b5060010190565b808201808211156200035d576200035d62000682565b818103818111156200035d576200035d62000682565b60805160a05160c05160e051610100516101205161014051616234620008146000396000611a8701526000818161067101528181611b4c01528181611b9c0152614d680152600081816103e801528181610d4001528181612749015281816127bb0152818161287901528181612cad0152614cb6015260008181613f150152613f5101526000818161087d01528181610c9f0152818161278b0152818161281601528181612c1301528181612c4701528181612c7601528181612cf801528181612d6301528181612f2e0152614c140152600061263d0152600081816104af015281816110790152818161164801528181611e7401528181611ed5015281816137470152818161386d015281816138d301528181613bad015281816142660152818161446801526144b801526162346000f3fe6080604052600436106102725760003560e01c80638da5cb5b1161014f578063b187bd26116100c1578063e5a986031161007a578063e5a9860314610801578063e75235b814610821578063f2fde38b14610836578063f5cfec1814610856578063fc0c546a1461086b578063fd96063c1461089f57600080fd5b8063b187bd261461070e578063b4d591bb14610723578063c0b07bde14610745578063c128d17014610783578063d788c147146107c1578063da4856a1146107e157600080fd5b806397c351461161011357806397c351461461064c5780639a8a05921461065f5780639d782454146106a65780639f86029c146106c65780639fd0506d146106e6578063a2713356146106fb57600080fd5b80638da5cb5b146105a95780638e3ba8c9146105d65780638fd3ab80146105f65780639057412d1461060b578063961b94d01461063957600080fd5b80633b97e856116101e85780637c918634116101ac5780637c918634146104d15780638129fc1c146104f15780638413bcba146105065780638456cb591461052657806386e11ffa1461053b57806389c619dd1461058957600080fd5b80633b97e856146104375780633f4ba83a1461045e5780634b4fd03b14610473578063689f90c31461048857806374aa7bfc1461049d57600080fd5b8063190171751161023a578063190171751461033c5780631f97c9a81461035c578063203e4a9b1461038957806323d75e31146103a9578063295a5212146103d6578063396c16b71461041757600080fd5b80630271725014610277578063036de8af146102aa5780630677df54146102cc5780630900f010146102fc578063186ce6121461031c575b600080fd5b34801561028357600080fd5b50610297610292366004615456565b6108fc565b6040519081526020015b60405180910390f35b3480156102b657600080fd5b506102ca6102c5366004615488565b610939565b005b3480156102d857600080fd5b506102ec6102e73660046154a5565b6109a5565b60405190151581526020016102a1565b34801561030857600080fd5b506102ca610317366004615488565b6109da565b34801561032857600080fd5b506102ca6103373660046154be565b6109ee565b34801561034857600080fd5b506102ca6103573660046154a5565b610a1b565b34801561036857600080fd5b5061037c610377366004615503565b610a46565b6040516102a19190615570565b34801561039557600080fd5b506102ca6103a4366004615488565b610b95565b3480156103b557600080fd5b506103be610c2f565b6040516001600160401b0390911681526020016102a1565b3480156103e257600080fd5b5061040a7f000000000000000000000000000000000000000000000000000000000000000081565b6040516102a191906155f1565b34801561042357600080fd5b506102ec6104323660046154a5565b610c48565b34801561044357600080fd5b5061044c610c66565b60405160ff90911681526020016102a1565b34801561046a57600080fd5b506102ca610d27565b34801561047f57600080fd5b5061044c610d3c565b34801561049457600080fd5b506102ec610d75565b3480156104a957600080fd5b506103be7f000000000000000000000000000000000000000000000000000000000000000081565b3480156104dd57600080fd5b506102ca6104ec366004615628565b610d88565b3480156104fd57600080fd5b506102ca610f04565b34801561051257600080fd5b506102ca6105213660046154a5565b611006565b34801561053257600080fd5b506102ca611151565b34801561054757600080fd5b50610550611164565b6040805182516001600160481b03908116825260208085015190911690820152918101516001600160401b0316908201526060016102a1565b34801561059557600080fd5b5061044c6105a43660046154a5565b6111c8565b3480156105b557600080fd5b506105be6111e1565b6040516001600160a01b0390911681526020016102a1565b3480156105e257600080fd5b506102ec6105f1366004615670565b61120f565b34801561060257600080fd5b506102ca611249565b34801561061757600080fd5b5061062b610626366004615780565b61134b565b6040516102a19291906157cf565b6103be610647366004615817565b61144e565b6103be61065a366004615503565b6114c5565b34801561066b57600080fd5b506106937f000000000000000000000000000000000000000000000000000000000000000081565b60405161ffff90911681526020016102a1565b3480156106b257600080fd5b506102ca6106c136600461584f565b611766565b3480156106d257600080fd5b506102ca6106e1366004615488565b611803565b3480156106f257600080fd5b506105be61189c565b6103be610709366004615913565b6118b5565b34801561071a57600080fd5b506102ec611914565b34801561072f57600080fd5b50610738611929565b6040516102a19190615988565b34801561075157600080fd5b50610776604051806040016040528060058152602001640302e312e360dc1b81525081565b6040516102a191906159d5565b34801561078f57600080fd5b506107a361079e366004615456565b611991565b604080518251815260209283015160ff1692810192909252016102a1565b3480156107cd57600080fd5b506105506107dc366004615456565b6119e1565b3480156107ed57600080fd5b506102ca6107fc36600461584f565b611a5c565b34801561080d57600080fd5b506102ca61081c3660046159e8565b611c6d565b34801561082d57600080fd5b5061044c611cf8565b34801561084257600080fd5b506102ca610851366004615488565b611d02565b34801561086257600080fd5b50610297611dc0565b34801561087757600080fd5b506105be7f000000000000000000000000000000000000000000000000000000000000000081565b3480156108ab57600080fd5b506108bf6108ba3660046154a5565b611df6565b6040805182516001600160481b031681526020808401516001600160401b031690820152918101516001600160a01b0316908201526060016102a1565b60008061091061090b846119e1565b611e70565b9050600061091c610c66565b90506109316001600160481b03831682611f75565b949350505050565b6109496109446111e1565b611f9f565b6000610953611fe8565b80546001600160a01b038481166001600160a01b031983168117845560405193945091169182907f51c4874e0f23f262e04a38c51751336dde72126d67f53eb672aaff02996b3ef690600090a3505050565b6000806109b0611cf8565b90508060ff166109bf846111c8565b60ff16101580156109d3575060008160ff16115b9392505050565b6109e2612016565b6109eb81612048565b50565b6109f6612016565b6000610a00610c66565b9050610a16610a10848380612156565b836121a3565b505050565b610a23612016565b6000610a2d610c66565b9050610a42610a3d838380612156565b6121c8565b5050565b6040805160c0810182526000808252602082018190529181018290526060808201839052608082019290925260a0810191909152610a826121d9565b6001600160401b0383811660009081526020928352604090819020815160c0810183528154815260018201546001600160481b03811695820195909552600160481b850490931691830191909152600160881b90920461ffff16606082015260028201546001600160a01b0316608082015260038201805491929160a084019190610b0c90615a05565b80601f0160208091040260200160405190810160405280929190818152602001828054610b3890615a05565b8015610b855780601f10610b5a57610100808354040283529160200191610b85565b820191906000526020600020905b815481529060010190602001808311610b6857829003601f168201915b5050505050815250509050919050565b610b9d612016565b610ba681612207565b506000610bb16124b9565b805490915060ff16600003610bcc57805460ff191660011781555b7ff05962b5774c658e85ed80c91a75af9d66d2af2253dda480f90bce78aff5eda582610bf66124e7565b548354604080516001600160a01b03909416845261010090920460ff908116602085015216908201526060015b60405180910390a15050565b6000610c39612515565b546001600160401b0316919050565b6000610c52612543565b600092835260205250604090205460ff1690565b60408051600481526024810182526020810180516001600160e01b031663313ce56760e01b179052905160009182916001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001691610cc991615a3f565b600060405180830381855afa9150503d8060008114610d04576040519150601f19603f3d011682016040523d82523d6000602084013e610d09565b606091505b5091505080806020019051810190610d219190615a5b565b91505090565b610d326109446111e1565b610d3a612571565b565b60007f00000000000000000000000000000000000000000000000000000000000000006001811115610d7057610d706155db565b905090565b6000610d7f6125d7565b5460ff16919050565b610d90612016565b8361ffff16600003610db55760405163100b0f2760e11b815260040160405180910390fd5b82610dd35760405163f839a0cb60e01b815260040160405180910390fd5b8160ff16600003610df75760405163ade64f0b60e01b815260040160405180910390fd5b6000610e01612605565b61ffff8616600090815260209182526040908190208151808301909252805482526001015460ff1691810191909152905083610e3b612605565b61ffff87166000908152602091909152604090205582610e59612605565b61ffff8716600090815260209190915260408120600101805460ff191660ff9390931692909217909155610e8b610c66565b9050610ea1610e9b848380612156565b876121a3565b81516020808401516040805193845260ff918216928401929092529082018790528516606082015261ffff8716907f1456404e7f41f35c3daac941bb50bad417a66275c3040061b4287d787719599d9060800160405180910390a2505050505050565b610f0c612633565b6000805160206161df8339815191528054600160401b810460ff1615906001600160401b0316600081158015610f3f5750825b90506000826001600160401b03166001148015610f5b5750303b155b905081158015610f69575080155b15610f875760405163f92ee8a960e01b815260040160405180910390fd5b845467ffffffffffffffff191660011785558315610fb157845460ff60401b1916600160401b1785555b610fb961267c565b8315610fff57845460ff60401b19168555604051600181527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b5050505050565b61100e612694565b611016611914565b15611034576040516309e3d0f360e11b815260040160405180910390fd5b600061103f82611df6565b905080602001516001600160401b031660000361107757604051630301bcaf60e61b8152600481018390526024015b60405180910390fd5b7f00000000000000000000000000000000000000000000000000000000000000006001600160401b031681602001516001600160401b0316426110ba9190615a8e565b10156110f15760208101516040516301cb739d60e71b8152600481018490526001600160401b03909116602482015260440161106e565b6110f96126cc565b600083815260209190915260409081902080546001600160881b031916815560010180546001600160a01b031916905581015181516111399184916126fa565b506109eb60016000805160206161bf83398151915255565b61115c6109446111e1565b610d3a6128dc565b604080516060810182526000808252602082018190529181019190915261118961293d565b6040805160608101825291546001600160481b038082168452600160481b8204166020840152600160901b90046001600160401b031690820152919050565b60006111db6111d68361296b565b6129a7565b92915050565b7f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300546001600160a01b031690565b600080600160ff84161b611221612543565b600086815260209190915260409020546101009004166001600160401b031611905092915050565b611251612633565b6112596129da565b611264906001615aa1565b6000805160206161df8339815191528054600160401b900460ff1680611297575080546001600160401b03808416911610155b156112b55760405163f92ee8a960e01b815260040160405180910390fd5b805468ffffffffffffffffff19166001600160401b03831617600160401b1781556112de6129f0565b5460ff166112ff57604051632866815360e11b815260040160405180910390fd5b611307612684565b805460ff60401b191681556040516001600160401b03831681527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d290602001610c23565b6060600080611358612a1e565b8054806020026020016040519081016040528092919081815260200182805480156113ac57602002820191906000526020600020905b81546001600160a01b0316815260019091019060200180831161138e575b50505050509050600073__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$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$93083e246e55d56d98f3df2872cd16bfd0$__638b4979b86040518060600160405280866001600160401b031660001b8152602001612fb78e6001600160a01b031690565b8152604080516315cfa3cb60e11b815287516001600160481b031660048201526020888101516024830152918801516044820152606088015161ffff16606482015291019073__$93083e246e55d56d98f3df2872cd16bfd0$__90632b9f479690608401600060405180830381865af4158015613038573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526130609190810190615dcd565b8152506040518263ffffffff1660e01b815260040161307f9190615e2a565b600060405180830381865af415801561309c573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526130c49190810190615dcd565b90506130f08c6130d2612605565b61ffff8f166000908152602091909152604090205487898b866146a7565b8c8c7f9716fe52fe4e02cf924ae28f19f5748ef59877c6496041b986fbad3dae6a8ecf8d61312f61311f610c66565b6001600160481b03861690611f75565b604080519283526020830191909152810188905261ffff831660608201526001600160401b038716608082015260a00160405180910390a1509d9e9d5050505050505050505050505050565b6000806111db60017f49bca747e973430e858f2f5de357b8dba36ea6d375b81bdb5d53dfaabf0b3a80615a8e565b806131b2612605565b61ffff84166000908152602091909152604090205414610a4257604051635788c0fd60e11b815261ffff831660048201526024810182905260440161106e565b60008073__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$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'; + +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 deploy( + _token: string, + _mode: BigNumberish, + _chainId: BigNumberish, + _rateLimitDuration: BigNumberish, + _skipRateLimiting: boolean, + overrides?: Overrides & { from?: string }, + ): Promise { + return super.deploy( + _token, + _mode, + _chainId, + _rateLimitDuration, + _skipRateLimiting, + overrides || {}, + ) as Promise; + } + override getDeployTransaction( + _token: string, + _mode: BigNumberish, + _chainId: BigNumberish, + _rateLimitDuration: BigNumberish, + _skipRateLimiting: boolean, + overrides?: Overrides & { from?: string }, + ): TransactionRequest { + return super.getDeployTransaction( + _token, + _mode, + _chainId, + _rateLimitDuration, + _skipRateLimiting, + overrides || {}, + ); + } + override attach(address: string): NttManager { + return super.attach(address) as NttManager; + } + override connect(signer: Signer): NttManager__factory { + return super.connect(signer) as NttManager__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): NttManagerInterface { + return new utils.Interface(_abi) as NttManagerInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider, + ): NttManager { + return new Contract(address, _abi, signerOrProvider) as NttManager; + } +} + +export interface NttManagerLibraryAddresses { + ['src/libraries/TransceiverStructs.sol:TransceiverStructs']: string; +} diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver.ts new file mode 100644 index 000000000..c0ba9c8e3 --- /dev/null +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver.ts @@ -0,0 +1,1468 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { + FunctionFragment, + Result, + EventFragment, +} from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from '../common'; + +export declare namespace TransceiverStructs { + export type TransceiverMessageStruct = { + sourceNttManagerAddress: BytesLike; + recipientNttManagerAddress: BytesLike; + nttManagerPayload: BytesLike; + transceiverPayload: BytesLike; + }; + + export type TransceiverMessageStructOutput = [ + string, + string, + string, + string, + ] & { + sourceNttManagerAddress: string; + recipientNttManagerAddress: string; + nttManagerPayload: string; + transceiverPayload: string; + }; + + export type TransceiverInstructionStruct = { + index: BigNumberish; + payload: BytesLike; + }; + + export type TransceiverInstructionStructOutput = [number, string] & { + index: number; + payload: string; + }; +} + +export declare namespace IWormholeTransceiver { + export type WormholeTransceiverInstructionStruct = { + shouldSkipRelayerSend: boolean; + }; + + export type WormholeTransceiverInstructionStructOutput = [boolean] & { + shouldSkipRelayerSend: boolean; + }; +} + +export interface WormholeTransceiverInterface extends utils.Interface { + functions: { + 'WORMHOLE_TRANSCEIVER_VERSION()': FunctionFragment; + 'consistencyLevel()': FunctionFragment; + 'encodeWormholeTransceiverInstruction((bool))': FunctionFragment; + 'gasLimit()': FunctionFragment; + 'getMigratesImmutables()': FunctionFragment; + 'getNttManagerOwner()': FunctionFragment; + 'getNttManagerToken()': FunctionFragment; + 'getWormholePeer(uint16)': FunctionFragment; + 'initialize()': FunctionFragment; + 'isPaused()': FunctionFragment; + 'isSpecialRelayingEnabled(uint16)': FunctionFragment; + 'isVAAConsumed(bytes32)': FunctionFragment; + 'isWormholeEvmChain(uint16)': FunctionFragment; + 'isWormholeRelayingEnabled(uint16)': FunctionFragment; + 'migrate()': FunctionFragment; + 'nttManager()': FunctionFragment; + 'nttManagerToken()': FunctionFragment; + 'owner()': FunctionFragment; + 'parseWormholeTransceiverInstruction(bytes)': FunctionFragment; + 'pauser()': FunctionFragment; + 'quoteDeliveryPrice(uint16,(uint8,bytes))': FunctionFragment; + 'receiveMessage(bytes)': FunctionFragment; + 'receiveWormholeMessages(bytes,bytes[],bytes32,uint16,bytes32)': FunctionFragment; + 'sendMessage(uint16,(uint8,bytes),bytes,bytes32)': FunctionFragment; + 'setIsSpecialRelayingEnabled(uint16,bool)': FunctionFragment; + 'setIsWormholeEvmChain(uint16,bool)': FunctionFragment; + 'setIsWormholeRelayingEnabled(uint16,bool)': FunctionFragment; + 'setWormholePeer(uint16,bytes32)': FunctionFragment; + 'specialRelayer()': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'transferPauserCapability(address)': FunctionFragment; + 'transferTransceiverOwnership(address)': FunctionFragment; + 'upgrade(address)': FunctionFragment; + 'wormhole()': FunctionFragment; + 'wormholeRelayer()': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'WORMHOLE_TRANSCEIVER_VERSION' + | 'consistencyLevel' + | 'encodeWormholeTransceiverInstruction' + | 'gasLimit' + | 'getMigratesImmutables' + | 'getNttManagerOwner' + | 'getNttManagerToken' + | 'getWormholePeer' + | 'initialize' + | 'isPaused' + | 'isSpecialRelayingEnabled' + | 'isVAAConsumed' + | 'isWormholeEvmChain' + | 'isWormholeRelayingEnabled' + | 'migrate' + | 'nttManager' + | 'nttManagerToken' + | 'owner' + | 'parseWormholeTransceiverInstruction' + | 'pauser' + | 'quoteDeliveryPrice' + | 'receiveMessage' + | 'receiveWormholeMessages' + | 'sendMessage' + | 'setIsSpecialRelayingEnabled' + | 'setIsWormholeEvmChain' + | 'setIsWormholeRelayingEnabled' + | 'setWormholePeer' + | 'specialRelayer' + | 'transferOwnership' + | 'transferPauserCapability' + | 'transferTransceiverOwnership' + | 'upgrade' + | 'wormhole' + | 'wormholeRelayer', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'WORMHOLE_TRANSCEIVER_VERSION', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'consistencyLevel', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'encodeWormholeTransceiverInstruction', + values: [IWormholeTransceiver.WormholeTransceiverInstructionStruct], + ): string; + encodeFunctionData(functionFragment: 'gasLimit', values?: undefined): string; + encodeFunctionData( + functionFragment: 'getMigratesImmutables', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getNttManagerOwner', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getNttManagerToken', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getWormholePeer', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'initialize', + values?: undefined, + ): string; + encodeFunctionData(functionFragment: 'isPaused', values?: undefined): string; + encodeFunctionData( + functionFragment: 'isSpecialRelayingEnabled', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'isVAAConsumed', + values: [BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'isWormholeEvmChain', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'isWormholeRelayingEnabled', + values: [BigNumberish], + ): string; + encodeFunctionData(functionFragment: 'migrate', values?: undefined): string; + encodeFunctionData( + functionFragment: 'nttManager', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'nttManagerToken', + values?: undefined, + ): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData( + functionFragment: 'parseWormholeTransceiverInstruction', + values: [BytesLike], + ): string; + encodeFunctionData(functionFragment: 'pauser', values?: undefined): string; + encodeFunctionData( + functionFragment: 'quoteDeliveryPrice', + values: [BigNumberish, TransceiverStructs.TransceiverInstructionStruct], + ): string; + encodeFunctionData( + functionFragment: 'receiveMessage', + values: [BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'receiveWormholeMessages', + values: [BytesLike, BytesLike[], BytesLike, BigNumberish, BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'sendMessage', + values: [ + BigNumberish, + TransceiverStructs.TransceiverInstructionStruct, + BytesLike, + BytesLike, + ], + ): string; + encodeFunctionData( + functionFragment: 'setIsSpecialRelayingEnabled', + values: [BigNumberish, boolean], + ): string; + encodeFunctionData( + functionFragment: 'setIsWormholeEvmChain', + values: [BigNumberish, boolean], + ): string; + encodeFunctionData( + functionFragment: 'setIsWormholeRelayingEnabled', + values: [BigNumberish, boolean], + ): string; + encodeFunctionData( + functionFragment: 'setWormholePeer', + values: [BigNumberish, BytesLike], + ): string; + encodeFunctionData( + functionFragment: 'specialRelayer', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'transferOwnership', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'transferPauserCapability', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'transferTransceiverOwnership', + values: [string], + ): string; + encodeFunctionData(functionFragment: 'upgrade', values: [string]): string; + encodeFunctionData(functionFragment: 'wormhole', values?: undefined): string; + encodeFunctionData( + functionFragment: 'wormholeRelayer', + values?: undefined, + ): string; + + decodeFunctionResult( + functionFragment: 'WORMHOLE_TRANSCEIVER_VERSION', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'consistencyLevel', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'encodeWormholeTransceiverInstruction', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'gasLimit', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'getMigratesImmutables', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getNttManagerOwner', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getNttManagerToken', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getWormholePeer', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'isPaused', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'isSpecialRelayingEnabled', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'isVAAConsumed', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'isWormholeEvmChain', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'isWormholeRelayingEnabled', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'migrate', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'nttManager', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'nttManagerToken', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'parseWormholeTransceiverInstruction', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'pauser', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'quoteDeliveryPrice', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'receiveMessage', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'receiveWormholeMessages', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'sendMessage', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setIsSpecialRelayingEnabled', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setIsWormholeEvmChain', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setIsWormholeRelayingEnabled', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setWormholePeer', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'specialRelayer', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferOwnership', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferPauserCapability', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferTransceiverOwnership', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'upgrade', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'wormhole', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'wormholeRelayer', + data: BytesLike, + ): Result; + + events: { + 'AdminChanged(address,address)': EventFragment; + 'BeaconUpgraded(address)': EventFragment; + 'Initialized(uint64)': EventFragment; + 'NotPaused(bool)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'Paused(bool)': EventFragment; + 'PauserTransferred(address,address)': EventFragment; + 'ReceivedMessage(bytes32,uint16,bytes32,uint64)': EventFragment; + 'ReceivedRelayedMessage(bytes32,uint16,bytes32)': EventFragment; + 'RelayingInfo(uint8,uint256)': EventFragment; + 'SendTransceiverMessage(uint16,(bytes32,bytes32,bytes,bytes))': EventFragment; + 'SetIsSpecialRelayingEnabled(uint16,bool)': EventFragment; + 'SetIsWormholeEvmChain(uint16,bool)': EventFragment; + 'SetIsWormholeRelayingEnabled(uint16,bool)': EventFragment; + 'SetWormholePeer(uint16,bytes32)': EventFragment; + 'Upgraded(address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'AdminChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'BeaconUpgraded'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'NotPaused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'PauserTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ReceivedMessage'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ReceivedRelayedMessage'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RelayingInfo'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'SendTransceiverMessage'): EventFragment; + getEvent( + nameOrSignatureOrTopic: 'SetIsSpecialRelayingEnabled', + ): EventFragment; + getEvent(nameOrSignatureOrTopic: 'SetIsWormholeEvmChain'): EventFragment; + getEvent( + nameOrSignatureOrTopic: 'SetIsWormholeRelayingEnabled', + ): EventFragment; + getEvent(nameOrSignatureOrTopic: 'SetWormholePeer'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Upgraded'): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface InitializedEventObject { + version: BigNumber; +} +export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface NotPausedEventObject { + notPaused: boolean; +} +export type NotPausedEvent = TypedEvent<[boolean], NotPausedEventObject>; + +export type NotPausedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface PausedEventObject { + paused: boolean; +} +export type PausedEvent = TypedEvent<[boolean], PausedEventObject>; + +export type PausedEventFilter = TypedEventFilter; + +export interface PauserTransferredEventObject { + oldPauser: string; + newPauser: string; +} +export type PauserTransferredEvent = TypedEvent< + [string, string], + PauserTransferredEventObject +>; + +export type PauserTransferredEventFilter = + TypedEventFilter; + +export interface ReceivedMessageEventObject { + digest: string; + emitterChainId: number; + emitterAddress: string; + sequence: BigNumber; +} +export type ReceivedMessageEvent = TypedEvent< + [string, number, string, BigNumber], + ReceivedMessageEventObject +>; + +export type ReceivedMessageEventFilter = TypedEventFilter; + +export interface ReceivedRelayedMessageEventObject { + digest: string; + emitterChainId: number; + emitterAddress: string; +} +export type ReceivedRelayedMessageEvent = TypedEvent< + [string, number, string], + ReceivedRelayedMessageEventObject +>; + +export type ReceivedRelayedMessageEventFilter = + TypedEventFilter; + +export interface RelayingInfoEventObject { + relayingType: number; + deliveryPayment: BigNumber; +} +export type RelayingInfoEvent = TypedEvent< + [number, BigNumber], + RelayingInfoEventObject +>; + +export type RelayingInfoEventFilter = TypedEventFilter; + +export interface SendTransceiverMessageEventObject { + recipientChain: number; + message: TransceiverStructs.TransceiverMessageStructOutput; +} +export type SendTransceiverMessageEvent = TypedEvent< + [number, TransceiverStructs.TransceiverMessageStructOutput], + SendTransceiverMessageEventObject +>; + +export type SendTransceiverMessageEventFilter = + TypedEventFilter; + +export interface SetIsSpecialRelayingEnabledEventObject { + chainId: number; + isRelayingEnabled: boolean; +} +export type SetIsSpecialRelayingEnabledEvent = TypedEvent< + [number, boolean], + SetIsSpecialRelayingEnabledEventObject +>; + +export type SetIsSpecialRelayingEnabledEventFilter = + TypedEventFilter; + +export interface SetIsWormholeEvmChainEventObject { + chainId: number; + isEvm: boolean; +} +export type SetIsWormholeEvmChainEvent = TypedEvent< + [number, boolean], + SetIsWormholeEvmChainEventObject +>; + +export type SetIsWormholeEvmChainEventFilter = + TypedEventFilter; + +export interface SetIsWormholeRelayingEnabledEventObject { + chainId: number; + isRelayingEnabled: boolean; +} +export type SetIsWormholeRelayingEnabledEvent = TypedEvent< + [number, boolean], + SetIsWormholeRelayingEnabledEventObject +>; + +export type SetIsWormholeRelayingEnabledEventFilter = + TypedEventFilter; + +export interface SetWormholePeerEventObject { + chainId: number; + peerContract: string; +} +export type SetWormholePeerEvent = TypedEvent< + [number, string], + SetWormholePeerEventObject +>; + +export type SetWormholePeerEventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface WormholeTransceiver extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: WormholeTransceiverInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined, + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter, + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter, + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + WORMHOLE_TRANSCEIVER_VERSION(overrides?: CallOverrides): Promise<[string]>; + + consistencyLevel(overrides?: CallOverrides): Promise<[number]>; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise<[string]>; + + gasLimit(overrides?: CallOverrides): Promise<[BigNumber]>; + + getMigratesImmutables(overrides?: CallOverrides): Promise<[boolean]>; + + getNttManagerOwner(overrides?: CallOverrides): Promise<[string]>; + + getNttManagerToken(overrides?: CallOverrides): Promise<[string]>; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise<[string]>; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise<[boolean]>; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isVAAConsumed( + hash: BytesLike, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + nttManager(overrides?: CallOverrides): Promise<[string]>; + + nttManagerToken(overrides?: CallOverrides): Promise<[string]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise< + [IWormholeTransceiver.WormholeTransceiverInstructionStructOutput] & { + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStructOutput; + } + >; + + pauser(overrides?: CallOverrides): Promise<[string]>; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise<[string]>; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise<[string]>; + + wormholeRelayer(overrides?: CallOverrides): Promise<[string]>; + }; + + WORMHOLE_TRANSCEIVER_VERSION(overrides?: CallOverrides): Promise; + + consistencyLevel(overrides?: CallOverrides): Promise; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + gasLimit(overrides?: CallOverrides): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getNttManagerOwner(overrides?: CallOverrides): Promise; + + getNttManagerToken(overrides?: CallOverrides): Promise; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isVAAConsumed(hash: BytesLike, overrides?: CallOverrides): Promise; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + nttManager(overrides?: CallOverrides): Promise; + + nttManagerToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise; + + wormholeRelayer(overrides?: CallOverrides): Promise; + + callStatic: { + WORMHOLE_TRANSCEIVER_VERSION(overrides?: CallOverrides): Promise; + + consistencyLevel(overrides?: CallOverrides): Promise; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + gasLimit(overrides?: CallOverrides): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getNttManagerOwner(overrides?: CallOverrides): Promise; + + getNttManagerToken(overrides?: CallOverrides): Promise; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize(overrides?: CallOverrides): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isVAAConsumed(hash: BytesLike, overrides?: CallOverrides): Promise; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + migrate(overrides?: CallOverrides): Promise; + + nttManager(overrides?: CallOverrides): Promise; + + nttManagerToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: CallOverrides, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: CallOverrides, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: CallOverrides, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: CallOverrides, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: CallOverrides, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: CallOverrides, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: CallOverrides, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: CallOverrides, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: CallOverrides, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: CallOverrides, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: CallOverrides, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise; + + wormholeRelayer(overrides?: CallOverrides): Promise; + }; + + filters: { + 'AdminChanged(address,address)'( + previousAdmin?: null, + newAdmin?: null, + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null, + ): AdminChangedEventFilter; + + 'BeaconUpgraded(address)'( + beacon?: string | null, + ): BeaconUpgradedEventFilter; + BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter; + + 'Initialized(uint64)'(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + 'NotPaused(bool)'(notPaused?: null): NotPausedEventFilter; + NotPaused(notPaused?: null): NotPausedEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + + 'Paused(bool)'(paused?: null): PausedEventFilter; + Paused(paused?: null): PausedEventFilter; + + 'PauserTransferred(address,address)'( + oldPauser?: string | null, + newPauser?: string | null, + ): PauserTransferredEventFilter; + PauserTransferred( + oldPauser?: string | null, + newPauser?: string | null, + ): PauserTransferredEventFilter; + + 'ReceivedMessage(bytes32,uint16,bytes32,uint64)'( + digest?: null, + emitterChainId?: null, + emitterAddress?: null, + sequence?: null, + ): ReceivedMessageEventFilter; + ReceivedMessage( + digest?: null, + emitterChainId?: null, + emitterAddress?: null, + sequence?: null, + ): ReceivedMessageEventFilter; + + 'ReceivedRelayedMessage(bytes32,uint16,bytes32)'( + digest?: null, + emitterChainId?: null, + emitterAddress?: null, + ): ReceivedRelayedMessageEventFilter; + ReceivedRelayedMessage( + digest?: null, + emitterChainId?: null, + emitterAddress?: null, + ): ReceivedRelayedMessageEventFilter; + + 'RelayingInfo(uint8,uint256)'( + relayingType?: null, + deliveryPayment?: null, + ): RelayingInfoEventFilter; + RelayingInfo( + relayingType?: null, + deliveryPayment?: null, + ): RelayingInfoEventFilter; + + 'SendTransceiverMessage(uint16,(bytes32,bytes32,bytes,bytes))'( + recipientChain?: null, + message?: null, + ): SendTransceiverMessageEventFilter; + SendTransceiverMessage( + recipientChain?: null, + message?: null, + ): SendTransceiverMessageEventFilter; + + 'SetIsSpecialRelayingEnabled(uint16,bool)'( + chainId?: null, + isRelayingEnabled?: null, + ): SetIsSpecialRelayingEnabledEventFilter; + SetIsSpecialRelayingEnabled( + chainId?: null, + isRelayingEnabled?: null, + ): SetIsSpecialRelayingEnabledEventFilter; + + 'SetIsWormholeEvmChain(uint16,bool)'( + chainId?: null, + isEvm?: null, + ): SetIsWormholeEvmChainEventFilter; + SetIsWormholeEvmChain( + chainId?: null, + isEvm?: null, + ): SetIsWormholeEvmChainEventFilter; + + 'SetIsWormholeRelayingEnabled(uint16,bool)'( + chainId?: null, + isRelayingEnabled?: null, + ): SetIsWormholeRelayingEnabledEventFilter; + SetIsWormholeRelayingEnabled( + chainId?: null, + isRelayingEnabled?: null, + ): SetIsWormholeRelayingEnabledEventFilter; + + 'SetWormholePeer(uint16,bytes32)'( + chainId?: null, + peerContract?: null, + ): SetWormholePeerEventFilter; + SetWormholePeer( + chainId?: null, + peerContract?: null, + ): SetWormholePeerEventFilter; + + 'Upgraded(address)'(implementation?: string | null): UpgradedEventFilter; + Upgraded(implementation?: string | null): UpgradedEventFilter; + }; + + estimateGas: { + WORMHOLE_TRANSCEIVER_VERSION(overrides?: CallOverrides): Promise; + + consistencyLevel(overrides?: CallOverrides): Promise; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + gasLimit(overrides?: CallOverrides): Promise; + + getMigratesImmutables(overrides?: CallOverrides): Promise; + + getNttManagerOwner(overrides?: CallOverrides): Promise; + + getNttManagerToken(overrides?: CallOverrides): Promise; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize(overrides?: Overrides & { from?: string }): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isVAAConsumed( + hash: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + migrate(overrides?: Overrides & { from?: string }): Promise; + + nttManager(overrides?: CallOverrides): Promise; + + nttManagerToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise; + + wormholeRelayer(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + WORMHOLE_TRANSCEIVER_VERSION( + overrides?: CallOverrides, + ): Promise; + + consistencyLevel(overrides?: CallOverrides): Promise; + + encodeWormholeTransceiverInstruction( + instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + gasLimit(overrides?: CallOverrides): Promise; + + getMigratesImmutables( + overrides?: CallOverrides, + ): Promise; + + getNttManagerOwner( + overrides?: CallOverrides, + ): Promise; + + getNttManagerToken( + overrides?: CallOverrides, + ): Promise; + + getWormholePeer( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize( + overrides?: Overrides & { from?: string }, + ): Promise; + + isPaused(overrides?: CallOverrides): Promise; + + isSpecialRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isVAAConsumed( + hash: BytesLike, + overrides?: CallOverrides, + ): Promise; + + isWormholeEvmChain( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + isWormholeRelayingEnabled( + chainId: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + migrate( + overrides?: Overrides & { from?: string }, + ): Promise; + + nttManager(overrides?: CallOverrides): Promise; + + nttManagerToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + parseWormholeTransceiverInstruction( + encoded: BytesLike, + overrides?: CallOverrides, + ): Promise; + + pauser(overrides?: CallOverrides): Promise; + + quoteDeliveryPrice( + targetChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + overrides?: CallOverrides, + ): Promise; + + receiveMessage( + encodedMessage: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + receiveWormholeMessages( + payload: BytesLike, + additionalMessages: BytesLike[], + sourceAddress: BytesLike, + sourceChain: BigNumberish, + deliveryHash: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + sendMessage( + recipientChain: BigNumberish, + instruction: TransceiverStructs.TransceiverInstructionStruct, + nttManagerMessage: BytesLike, + recipientNttManagerAddress: BytesLike, + overrides?: PayableOverrides & { from?: string }, + ): Promise; + + setIsSpecialRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeEvmChain( + chainId: BigNumberish, + isEvm: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setIsWormholeRelayingEnabled( + chainId: BigNumberish, + isEnabled: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setWormholePeer( + peerChainId: BigNumberish, + peerContract: BytesLike, + overrides?: Overrides & { from?: string }, + ): Promise; + + specialRelayer(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferPauserCapability( + newPauser: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferTransceiverOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + upgrade( + newImplementation: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + wormhole(overrides?: CallOverrides): Promise; + + wormholeRelayer(overrides?: CallOverrides): Promise; + }; +} diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver__factory.ts new file mode 100644 index 000000000..6e4e00eaa --- /dev/null +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver__factory.ts @@ -0,0 +1,1364 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { + Signer, + utils, + Contract, + ContractFactory, + BigNumberish, + Overrides, +} from 'ethers'; +import type { Provider, TransactionRequest } from '@ethersproject/providers'; +import type { + WormholeTransceiver, + WormholeTransceiverInterface, +} from './WormholeTransceiver'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: 'nttManager', + type: 'address', + }, + { + internalType: 'address', + name: 'wormholeCoreBridge', + type: 'address', + }, + { + internalType: 'address', + name: 'wormholeRelayerAddr', + type: 'address', + }, + { + internalType: 'address', + name: 'specialRelayerAddr', + type: 'address', + }, + { + internalType: 'uint8', + name: '_consistencyLevel', + type: 'uint8', + }, + { + internalType: 'uint256', + name: '_gasLimit', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [ + { + internalType: 'address', + name: 'caller', + type: 'address', + }, + ], + name: 'CallerNotNttManager', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'caller', + type: 'address', + }, + ], + name: 'CallerNotRelayer', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'currentOwner', + type: 'address', + }, + ], + name: 'CannotRenounceTransceiverOwnership', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'currentOwner', + type: 'address', + }, + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'CannotTransferTransceiverOwnership', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint8', + name: 'val', + type: 'uint8', + }, + ], + name: 'InvalidBoolVal', + type: 'error', + }, + { + inputs: [ + { + internalType: 'BooleanFlag', + name: 'value', + type: 'uint256', + }, + ], + name: 'InvalidBoolValue', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'evmChainId', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'blockChainId', + type: 'uint256', + }, + ], + name: 'InvalidFork', + type: 'error', + }, + { + inputs: [], + name: 'InvalidInitialization', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'InvalidPauser', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'InvalidRelayingConfig', + type: 'error', + }, + { + inputs: [ + { + internalType: 'string', + name: 'reason', + type: 'string', + }, + ], + name: 'InvalidVaa', + type: 'error', + }, + { + inputs: [], + name: 'InvalidWormholeChainIdZero', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerAddress', + type: 'bytes32', + }, + ], + name: 'InvalidWormholePeer', + type: 'error', + }, + { + inputs: [], + name: 'InvalidWormholePeerZeroAddress', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'encodedLength', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'expectedLength', + type: 'uint256', + }, + ], + name: 'LengthMismatch', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: '', + type: 'bytes32', + }, + ], + name: 'NotAnEvmAddress', + type: 'error', + }, + { + inputs: [], + name: 'NotInitializing', + type: 'error', + }, + { + inputs: [], + name: 'NotMigrating', + type: 'error', + }, + { + inputs: [], + name: 'OnlyDelegateCall', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'OwnableInvalidOwner', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'OwnableUnauthorizedAccount', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerAddress', + type: 'bytes32', + }, + ], + name: 'PeerAlreadySet', + type: 'error', + }, + { + inputs: [], + name: 'ReentrancyGuardReentrantCall', + type: 'error', + }, + { + inputs: [], + name: 'RequireContractIsNotPaused', + type: 'error', + }, + { + inputs: [], + name: 'RequireContractIsPaused', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'vaaHash', + type: 'bytes32', + }, + ], + name: 'TransferAlreadyCompleted', + type: 'error', + }, + { + inputs: [], + name: 'UnexpectedAdditionalMessages', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'deployer', + type: 'address', + }, + { + internalType: 'address', + name: 'caller', + type: 'address', + }, + ], + name: 'UnexpectedDeployer', + type: 'error', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'recipientNttManagerAddress', + type: 'bytes32', + }, + { + internalType: 'bytes32', + name: 'expectedRecipientNttManagerAddress', + type: 'bytes32', + }, + ], + name: 'UnexpectedRecipientNttManagerAddress', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'previousAdmin', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'newAdmin', + type: 'address', + }, + ], + name: 'AdminChanged', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'beacon', + type: 'address', + }, + ], + name: 'BeaconUpgraded', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint64', + name: 'version', + type: 'uint64', + }, + ], + name: 'Initialized', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bool', + name: 'notPaused', + type: 'bool', + }, + ], + name: 'NotPaused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'previousOwner', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnershipTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bool', + name: 'paused', + type: 'bool', + }, + ], + name: 'Paused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'oldPauser', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newPauser', + type: 'address', + }, + ], + name: 'PauserTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint16', + name: 'emitterChainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'emitterAddress', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint64', + name: 'sequence', + type: 'uint64', + }, + ], + name: 'ReceivedMessage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'bytes32', + name: 'digest', + type: 'bytes32', + }, + { + indexed: false, + internalType: 'uint16', + name: 'emitterChainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'emitterAddress', + type: 'bytes32', + }, + ], + name: 'ReceivedRelayedMessage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint8', + name: 'relayingType', + type: 'uint8', + }, + { + indexed: false, + internalType: 'uint256', + name: 'deliveryPayment', + type: 'uint256', + }, + ], + name: 'RelayingInfo', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + components: [ + { + internalType: 'bytes32', + name: 'sourceNttManagerAddress', + type: 'bytes32', + }, + { + internalType: 'bytes32', + name: 'recipientNttManagerAddress', + type: 'bytes32', + }, + { + internalType: 'bytes', + name: 'nttManagerPayload', + type: 'bytes', + }, + { + internalType: 'bytes', + name: 'transceiverPayload', + type: 'bytes', + }, + ], + indexed: false, + internalType: 'struct TransceiverStructs.TransceiverMessage', + name: 'message', + type: 'tuple', + }, + ], + name: 'SendTransceiverMessage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bool', + name: 'isRelayingEnabled', + type: 'bool', + }, + ], + name: 'SetIsSpecialRelayingEnabled', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bool', + name: 'isEvm', + type: 'bool', + }, + ], + name: 'SetIsWormholeEvmChain', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bool', + name: 'isRelayingEnabled', + type: 'bool', + }, + ], + name: 'SetIsWormholeRelayingEnabled', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + indexed: false, + internalType: 'bytes32', + name: 'peerContract', + type: 'bytes32', + }, + ], + name: 'SetWormholePeer', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'implementation', + type: 'address', + }, + ], + name: 'Upgraded', + type: 'event', + }, + { + inputs: [], + name: 'WORMHOLE_TRANSCEIVER_VERSION', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'consistencyLevel', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + components: [ + { + internalType: 'bool', + name: 'shouldSkipRelayerSend', + type: 'bool', + }, + ], + internalType: + 'struct IWormholeTransceiver.WormholeTransceiverInstruction', + name: 'instruction', + type: 'tuple', + }, + ], + name: 'encodeWormholeTransceiverInstruction', + outputs: [ + { + internalType: 'bytes', + name: '', + type: 'bytes', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [], + name: 'gasLimit', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getMigratesImmutables', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getNttManagerOwner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getNttManagerToken', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'getWormholePeer', + outputs: [ + { + internalType: 'bytes32', + name: '', + type: 'bytes32', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'initialize', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'isPaused', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'isSpecialRelayingEnabled', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes32', + name: 'hash', + type: 'bytes32', + }, + ], + name: 'isVAAConsumed', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'isWormholeEvmChain', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + ], + name: 'isWormholeRelayingEnabled', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'migrate', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'nttManager', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'nttManagerToken', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes', + name: 'encoded', + type: 'bytes', + }, + ], + name: 'parseWormholeTransceiverInstruction', + outputs: [ + { + components: [ + { + internalType: 'bool', + name: 'shouldSkipRelayerSend', + type: 'bool', + }, + ], + internalType: + 'struct IWormholeTransceiver.WormholeTransceiverInstruction', + name: 'instruction', + type: 'tuple', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [], + name: 'pauser', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'targetChain', + type: 'uint16', + }, + { + components: [ + { + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.TransceiverInstruction', + name: 'instruction', + type: 'tuple', + }, + ], + name: 'quoteDeliveryPrice', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes', + name: 'encodedMessage', + type: 'bytes', + }, + ], + name: 'receiveMessage', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + { + internalType: 'bytes[]', + name: 'additionalMessages', + type: 'bytes[]', + }, + { + internalType: 'bytes32', + name: 'sourceAddress', + type: 'bytes32', + }, + { + internalType: 'uint16', + name: 'sourceChain', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'deliveryHash', + type: 'bytes32', + }, + ], + name: 'receiveWormholeMessages', + outputs: [], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'recipientChain', + type: 'uint16', + }, + { + components: [ + { + internalType: 'uint8', + name: 'index', + type: 'uint8', + }, + { + internalType: 'bytes', + name: 'payload', + type: 'bytes', + }, + ], + internalType: 'struct TransceiverStructs.TransceiverInstruction', + name: 'instruction', + type: 'tuple', + }, + { + internalType: 'bytes', + name: 'nttManagerMessage', + type: 'bytes', + }, + { + internalType: 'bytes32', + name: 'recipientNttManagerAddress', + type: 'bytes32', + }, + ], + name: 'sendMessage', + outputs: [], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bool', + name: 'isEnabled', + type: 'bool', + }, + ], + name: 'setIsSpecialRelayingEnabled', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bool', + name: 'isEvm', + type: 'bool', + }, + ], + name: 'setIsWormholeEvmChain', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'chainId', + type: 'uint16', + }, + { + internalType: 'bool', + name: 'isEnabled', + type: 'bool', + }, + ], + name: 'setIsWormholeRelayingEnabled', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint16', + name: 'peerChainId', + type: 'uint16', + }, + { + internalType: 'bytes32', + name: 'peerContract', + type: 'bytes32', + }, + ], + name: 'setWormholePeer', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'specialRelayer', + outputs: [ + { + internalType: 'contract ISpecialRelayer', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newPauser', + type: 'address', + }, + ], + name: 'transferPauserCapability', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferTransceiverOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newImplementation', + type: 'address', + }, + ], + name: 'upgrade', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'wormhole', + outputs: [ + { + internalType: 'contract IWormhole', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'wormholeRelayer', + outputs: [ + { + internalType: 'contract IWormholeRelayer', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, +] as const; + +const _bytecode = + '0x6101c06040523480156200001257600080fd5b5060405162003fcd38038062003fcd8339810160408190526200003591620001d3565b858585858585856200004662000102565b306080526001600160a01b03811660a081905260408051637e062a3560e11b8152905163fc0c546a916004808201926020929091908290030181865afa15801562000095573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620000bb919062000254565b6001600160a01b0390811660c0523360e052958616610120525092841661014052921661016052466101805260ff909116610100526101a052506200027995505050505050565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00805468010000000000000000900460ff1615620001535760405163f92ee8a960e01b815260040160405180910390fd5b80546001600160401b0390811614620001b35780546001600160401b0319166001600160401b0390811782556040519081527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b50565b80516001600160a01b0381168114620001ce57600080fd5b919050565b60008060008060008060c08789031215620001ed57600080fd5b620001f887620001b6565b95506200020860208801620001b6565b94506200021860408801620001b6565b93506200022860608801620001b6565b9250608087015160ff811681146200023f57600080fd5b8092505060a087015190509295509295509295565b6000602082840312156200026757600080fd5b6200027282620001b6565b9392505050565b60805160a05160c05160e05161010051610120516101405161016051610180516101a051613bc06200040d600039600081816106fc01528181611ac80152611ea401526000612bd701526000818161052e01528181611b86015281816120c7015261268d01526000818161062f015281816108d201528181611aef01528181611e5f01526125eb0152600081816104d001528181610ccb015281816119e301528181611c4901528181611cde01528181611f8201528181612008015281816121f401528181612344015281816125490152612a5701526000818161066301528181610d600152818161203b015281816122280152818161272f0152612ae70152600081816127e9015261282501526000818161025d0152818161041401528181611bad015281816120f8015281816129500152612d660152600081816102ae01528181610ad5015281816111830152818161121b015281816116f0015281816117250152818161177801528181612897015281816128be015281816129770152612cc4015260006118ee0152613bc06000f3fe6080604052600436106102045760003560e01c806384acd1bb11610118578063bc7f6d37116100a0578063ee1d0c621161006f578063ee1d0c6214610697578063f2fde38b146106aa578063f48066a8146106ca578063f68016b7146106ea578063f953cec71461071e57600080fd5b8063bc7f6d37146105e8578063d8d2841814610608578063da25b7251461061d578063e8dfd5081461065157600080fd5b8063935dec07116100e7578063935dec071461055057806396dddc631461057e5780639fd0506d1461059e578063b187bd26146105b3578063b5634c73146105c857600080fd5b806384acd1bb146104be5780638da5cb5b146104f25780638fd3ab801461050757806390ea54281461051c57600080fd5b806358f709ba1161019b578063694977d71161016a578063694977d7146104055780637ab564031461043857806380eb3239146104585780638129fc1c1461047857806381e8ec7f1461048d57600080fd5b806358f709ba14610364578063657b3b2f1461038457806366152efc146103a4578063689f90c3146103f057600080fd5b8063320d0d8e116101d7578063320d0d8e146102d057806348b330d6146103005780634b795b2114610331578063529dca321461035157600080fd5b8063036de8af146102095780630900f0101461022b5780630b4a1e891461024b57806324fb21db1461029c575b600080fd5b34801561021557600080fd5b50610229610224366004612f1c565b61073e565b005b34801561023757600080fd5b50610229610246366004612f1c565b6107aa565b34801561025757600080fd5b5061027f7f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b0390911681526020015b60405180910390f35b3480156102a857600080fd5b5061027f7f000000000000000000000000000000000000000000000000000000000000000081565b3480156102dc57600080fd5b506102f06102eb366004612f54565b6107be565b6040519015158152602001610293565b34801561030c57600080fd5b5061032061031b36600461307f565b6107eb565b604051905115158152602001610293565b34801561033d57600080fd5b5061022961034c3660046130c9565b61082f565b61022961035f366004613125565b6108c7565b34801561037057600080fd5b5061022961037f366004612f1c565b610aca565b34801561039057600080fd5b5061022961039f3660046130c9565b610b1e565b3480156103b057600080fd5b506103e36103bf36600461321a565b516040805191151560f81b6020830152805160018184030181526021909201905290565b60405161029391906132b5565b3480156103fc57600080fd5b506102f0610bae565b34801561041157600080fd5b507f000000000000000000000000000000000000000000000000000000000000000061027f565b34801561044457600080fd5b506102296104533660046132c8565b610bc1565b34801561046457600080fd5b506102f06104733660046132f4565b610e24565b34801561048457600080fd5b50610229610e42565b34801561049957600080fd5b506103e3604051806040016040528060058152602001640302e312e360dc1b81525081565b3480156104ca57600080fd5b5061027f7f000000000000000000000000000000000000000000000000000000000000000081565b3480156104fe57600080fd5b5061027f610f44565b34801561051357600080fd5b50610229610f72565b34801561052857600080fd5b5061027f7f000000000000000000000000000000000000000000000000000000000000000081565b34801561055c57600080fd5b5061057061056b366004612f54565b61107d565b604051908152602001610293565b34801561058a57600080fd5b506102296105993660046130c9565b6110a1565b3480156105aa57600080fd5b5061027f611131565b3480156105bf57600080fd5b506102f061114a565b3480156105d457600080fd5b506105706105e3366004613395565b61115f565b3480156105f457600080fd5b506102f0610603366004612f54565b611172565b34801561061457600080fd5b5061027f61117f565b34801561062957600080fd5b5061027f7f000000000000000000000000000000000000000000000000000000000000000081565b34801561065d57600080fd5b506106857f000000000000000000000000000000000000000000000000000000000000000081565b60405160ff9091168152602001610293565b6102296106a53660046133e4565b611208565b3480156106b657600080fd5b506102296106c5366004612f1c565b611298565b3480156106d657600080fd5b506102f06106e5366004612f54565b6112ca565b3480156106f657600080fd5b506105707f000000000000000000000000000000000000000000000000000000000000000081565b34801561072a57600080fd5b5061022961073936600461307f565b6112d7565b61074e610749610f44565b6113c7565b6000610758611410565b80546001600160a01b038481166001600160a01b031983168117845560405193945091169182907f51c4874e0f23f262e04a38c51751336dde72126d67f53eb672aaff02996b3ef690600090a3505050565b6107b261143e565b6107bb81611472565b50565b60006107e56107cb611580565b61ffff8416600090815260209190915260409020546115ae565b92915050565b604080516020810190915260008152815160000361080c5760008152919050565b600061081883826115ec565b901515835290506108298382611641565b50919050565b61083761143e565b8161ffff1660000361085c57604051630f7662c960e21b815260040160405180910390fd5b610867811515611673565b61086f611690565b61ffff841660008181526020928352604090819020939093558251908152831515918101919091527f0fe301480713b2c2072ee91b3bcfcbf2c0014f0447c89046f020f0f80727003c91015b60405180910390a15050565b336001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161461091757604051631c26958960e01b81523360048201526024015b60405180910390fd5b826109218361107d565b1461094c57604051633cd8e72b60e11b815261ffff831660048201526024810184905260440161090e565b61095581610e24565b1561097657604051632d30ec0360e21b81526004810182905260240161090e565b61097f816116be565b83511561099f5760405163c504ea2960e01b815260040160405180910390fd5b6040805182815261ffff841660208201529081018490527ff557dbbb087662f52c815f6c7ee350628a37a51eae9608ff840d996b65f874759060600160405180910390a1604080516080810182526000808252602082015260609181018290528181019190915260408051606080820183526000808352602083015291810191909152604051630453806b60e11b815273__$93083e246e55d56d98f3df2872cd16bfd0$__906308a700d690610a62906309945ff160e41b908b90600401613461565b600060405180830381865af4158015610a7f573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610aa7919081019061354a565b81516020830151929450909250610ac191869190846116e6565b50505050505050565b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614610b155760405163c5aa615360e01b815233600482015260240161090e565b6107bb816117e9565b610b2661143e565b8161ffff16600003610b4b57604051630f7662c960e21b815260040160405180910390fd5b610b56811515611673565b610b5e611580565b61ffff841660008181526020928352604090819020939093558251908152831515918101919091527f528b18a533e892b5401d1fb63597275df9d2bb45b13e7695c3147cd07b9746c391016108bb565b6000610bb861185a565b5460ff16919050565b610bc961143e565b8161ffff16600003610bee57604051630f7662c960e21b815260040160405180910390fd5b80610c0c5760405163137063ef60e11b815260040160405180910390fd5b6000610c16611888565b61ffff84166000908152602091909152604090205490508015610c595760405163b55eeae960e01b815261ffff841660048201526024810182905260440161090e565b81610c62611888565b61ffff858116600081815260209384526040808220959095558451606081018652630c7e33e160e11b8152938401918252838501878152945163077650fb60e51b815284516001600160e01b0319166004820152915190921660248201529251604484015290917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169163b19a437e9173__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$__90631185b23c90611dea906309945ff160e41b906001600160a01b038b16908a908990602481016137df565b600060405180830381865af4158015611e07573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611e2f919081019061382b565b915091506000611e4285602001516107eb565b8051909150158015611e585750611e5889612b89565b15611f66577f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316638fecdd02898b611e9f611e9a8e61107d565b612ba4565b8660007f00000000000000000000000000000000000000000000000000000000000000006040518763ffffffff1660e01b8152600401611ee3959493929190613884565b60206040518083038185885af1158015611f01573d6000803e3d6000fd5b50505050506040513d601f19601f82011682018060405250810190611f269190613686565b506040805160008152602081018a90527f375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271910160405180910390a16122cf565b8051158015611f795750611f7989611172565b156121dd5760007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316631a90a2196040518163ffffffff1660e01b8152600401602060405180830381865afa158015611fde573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612002919061378f565b905060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663b19a437e836000877f00000000000000000000000000000000000000000000000000000000000000006040518563ffffffff1660e01b81526004016120789392919061363d565b60206040518083038185885af1158015612096573d6000803e3d6000fd5b50505050506040513d601f19601f820116820180604052508101906120bb9190613686565b90506001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000166316ac49c26120f6848d6136f4565b7f00000000000000000000000000000000000000000000000000000000000000006040516001600160e01b031960e085901b1681526001600160a01b03909116600482015261ffff8f166024820152600060448201526001600160401b03851660648201526084016000604051808303818588803b15801561217757600080fd5b505af115801561218b573d6000803e3d6000fd5b507f375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f52762719350600192506121bb915050565b6040805160ff9092168252602082018d90520160405180910390a150506122cf565b6040516358cd21bf60e11b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063b19a437e908a906122509060009087907f00000000000000000000000000000000000000000000000000000000000000009060040161363d565b60206040518083038185885af115801561226e573d6000803e3d6000fd5b50505050506040513d601f19601f820116820180604052508101906122939190613686565b506040805160028152602081018a90527f375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271910160405180910390a15b7f79376a0dc6cbfe6f6f8f89ad24c262a8c6233f8df181d3fe5abb2e2442e8c73889846040516123009291906138c6565b60405180910390a1505050505050505050565b60017f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f0055565b6000606060008060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663c0fd8bde876040518263ffffffff1660e01b815260040161238e91906132b5565b600060405180830381865afa1580156123ab573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526123d391908101906139f6565b925092509250816123f95780604051634771719b60e11b815260040161090e91906132b5565b61240283612bd0565b6124355760608301516080840151604051633cd8e72b60e11b815261ffff9092166004830152602482015260440161090e565b612443836101400151610e24565b1561246a57826101400151604051632d30ec0360e21b815260040161090e91815260200190565b6124788361014001516116be565b7ff6fc529540981400dc64edf649eb5e2e0eb5812a27f8c81bac2c1d317e71a5f0836101400151846060015185608001518660a001516040516124e1949392919093845261ffff92909216602084015260408301526001600160401b0316606082015260800190565b60405180910390a182606001518360e0015194509450505050915091565b61250881612c14565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b612547612cc2565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316306001600160a01b03166384acd1bb6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156125af573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906125d391906136d7565b6001600160a01b0316146125e9576125e9613707565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316306001600160a01b031663da25b7256040518163ffffffff1660e01b8152600401602060405180830381865afa158015612651573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061267591906136d7565b6001600160a01b03161461268b5761268b613707565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316306001600160a01b03166390ea54286040518163ffffffff1660e01b8152600401602060405180830381865afa1580156126f3573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061271791906136d7565b6001600160a01b03161461272d5761272d613707565b7f000000000000000000000000000000000000000000000000000000000000000060ff16306001600160a01b031663e8dfd5086040518163ffffffff1660e01b8152600401602060405180830381865afa15801561278f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906127b39190613b4d565b60ff161461147057611470613707565b806127cc61185a565b805460ff191691151591909117905550565b336001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161461285857604051636345072160e11b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016600482015233602482015260440161090e565b612860612e06565b6114703361286c61117f565b612e16565b6040805160a08101909152639c23bd3b60e01b8152600090602081016001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001681526020017f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316634b4fd03b6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561291a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061293e9190613b4d565b60ff1681526020016001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001681526020017f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316633b97e8566040518163ffffffff1660e01b8152600401602060405180830381865afa1580156129d3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129f79190613b4d565b60ff908116909152604080516301529f6160e21b815283516001600160e01b031916600482015260208401516024820152908301518216604482015260608301516064820152608083015190911660848201529091506001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063b19a437e9060009073__$93083e246e55d56d98f3df2872cd16bfd0$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'; + +type WormholeTransceiverConstructorParams = + | [linkLibraryAddresses: WormholeTransceiverLibraryAddresses, signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: WormholeTransceiverConstructorParams, +): 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 WormholeTransceiver__factory extends ContractFactory { + constructor(...args: WormholeTransceiverConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + const [linkLibraryAddresses, signer] = args; + super( + _abi, + WormholeTransceiver__factory.linkBytecode(linkLibraryAddresses), + signer, + ); + } + } + + static linkBytecode( + linkLibraryAddresses: WormholeTransceiverLibraryAddresses, + ): string { + let linkedBytecode = _bytecode; + + linkedBytecode = linkedBytecode.replace( + new RegExp('__\\$93083e246e55d56d98f3df2872cd16bfd0\\$__', 'g'), + linkLibraryAddresses[ + 'src/libraries/TransceiverStructs.sol:TransceiverStructs' + ] + .replace(/^0x/, '') + .toLowerCase(), + ); + + return linkedBytecode; + } + + override deploy( + nttManager: string, + wormholeCoreBridge: string, + wormholeRelayerAddr: string, + specialRelayerAddr: string, + _consistencyLevel: BigNumberish, + _gasLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise { + return super.deploy( + nttManager, + wormholeCoreBridge, + wormholeRelayerAddr, + specialRelayerAddr, + _consistencyLevel, + _gasLimit, + overrides || {}, + ) as Promise; + } + override getDeployTransaction( + nttManager: string, + wormholeCoreBridge: string, + wormholeRelayerAddr: string, + specialRelayerAddr: string, + _consistencyLevel: BigNumberish, + _gasLimit: BigNumberish, + overrides?: Overrides & { from?: string }, + ): TransactionRequest { + return super.getDeployTransaction( + nttManager, + wormholeCoreBridge, + wormholeRelayerAddr, + specialRelayerAddr, + _consistencyLevel, + _gasLimit, + overrides || {}, + ); + } + override attach(address: string): WormholeTransceiver { + return super.attach(address) as WormholeTransceiver; + } + override connect(signer: Signer): WormholeTransceiver__factory { + return super.connect(signer) as WormholeTransceiver__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): WormholeTransceiverInterface { + return new utils.Interface(_abi) as WormholeTransceiverInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider, + ): WormholeTransceiver { + return new Contract(address, _abi, signerOrProvider) as WormholeTransceiver; + } +} + +export interface WormholeTransceiverLibraryAddresses { + ['src/libraries/TransceiverStructs.sol:TransceiverStructs']: string; +} diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/index.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/index.ts deleted file mode 100644 index a0955ab2e..000000000 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/index.ts +++ /dev/null @@ -1,3 +0,0 @@ -export * from './NttManager__factory'; -export * from './NttManager'; -export * from './WormholeTransceiver__factory'; diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager.ts similarity index 99% rename from wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager.ts index 2ddda09b0..013f9e8d5 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager.ts @@ -25,7 +25,7 @@ import type { TypedEvent, TypedListener, OnEvent, -} from './common'; +} from '../common'; export declare namespace TransceiverStructs { export type NttManagerMessageStruct = { diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager__factory.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/chains/evm/abis/NttManager__factory.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager__factory.ts diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver.ts similarity index 99% rename from wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver.ts index eb1387cbe..1ad1c067d 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver.ts @@ -25,7 +25,7 @@ import type { TypedEvent, TypedListener, OnEvent, -} from './common'; +} from '../common'; export declare namespace TransceiverStructs { export type TransceiverMessageStruct = { diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver__factory.ts similarity index 100% rename from wormhole-connect/src/routes/ntt/chains/evm/abis/WormholeTransceiver__factory.ts rename to wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver__factory.ts diff --git a/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts b/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts index 09e1e828b..1a434d1f6 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts @@ -10,7 +10,6 @@ import { hexlify } from 'ethers/lib/utils'; import { NttRelayingType, UnsignedNttMessage } from 'routes/types'; import { getTokenById, getTokenDecimals } from 'utils'; import { getWormholeLogEvm } from 'utils/vaa'; -import { NttManager__factory } from './abis'; import config from 'config'; import { toChainName } from 'utils/sdk'; import { deserializePayload, Ntt } from '@wormhole-foundation/sdk-definitions'; @@ -37,8 +36,13 @@ export const getMessageEvm = async ( receipt = await provider.getTransactionReceipt(tx); if (!receipt) throw new Error(`No receipt for tx ${tx} on ${chain}`); } - const nttManager = NttManager__factory.connect(receipt.to, provider); - const tokenAddress = await nttManager.token(); + const contract = new ethers.Contract( + receipt.to, + ['function token() public view returns (address)'], + provider, + ); + const tokenAddress = await contract.token(); + if (!tokenAddress) throw new Error('No token address'); const fromChain = toChainName(chain); const tokenId = { chain: fromChain, diff --git a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts index 334f57fa1..9a7dee0c1 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts @@ -7,33 +7,40 @@ import { } from '@wormhole-foundation/wormhole-connect-sdk'; import { getTokenById, tryParseErrorMessage } from 'utils'; import { TransferWallet, signAndSendTransaction } from 'utils/wallet'; -import { BigNumber, PopulatedTransaction } from 'ethers'; +import { BaseContract, BigNumber, ethers, PopulatedTransaction } from 'ethers'; import { InboundQueuedTransfer } from '../../types'; import { InboundQueuedTransferNotFoundError, InboundQueuedTransferStillQueuedError, NotEnoughCapacityError, ContractIsPausedError, + UnsupportedContractAbiVersion, } from '../../errors'; import { encodeTransceiverInstructions, encodeWormholeTransceiverInstruction, } from 'routes/ntt/utils'; -import { NttManager__factory } from './abis/NttManager__factory'; -import { NttManager as NttManagerAbi } from './abis/NttManager'; +import { NttManager__factory as NttManager__factory_testnet } from './abis/testnet/NttManager__factory'; +import { NttManager as NttManager_testnet } from './abis/testnet/NttManager'; +import { NttManager__factory as NttManager__factory_0_1_0 } from './abis/0.1.0/NttManager__factory'; +import { NttManager as NttManager_0_1_0 } from './abis/0.1.0/NttManager'; import config from 'config'; import { toChainId, toChainName } from 'utils/sdk'; import { getNttManagerConfigByAddress } from 'utils/ntt'; +const ABI_VERSION_0_1_0 = '0.1.0'; + +function isAbiVersion_0_1_0( + version: string, + abi: BaseContract, +): abi is NttManager_0_1_0 { + return version === ABI_VERSION_0_1_0; +} + export class NttManagerEvm { - readonly nttManager: NttManagerAbi; + static readonly abiVersionCache = new Map(); - constructor(readonly chain: ChainName | ChainId, address: string) { - this.nttManager = NttManager__factory.connect( - address, - config.wh.mustGetProvider(chain), - ); - } + constructor(readonly chain: ChainName | ChainId, readonly address: string) {} async signAndSendTransaction( tx: PopulatedTransaction, @@ -55,30 +62,37 @@ export class NttManagerEvm { destChain: ChainName | ChainId, wormholeTransceiver: string, ): Promise { - // TODO: when this change is deployed, change to encodeTransceiverInstructions - // https://github.com/wormhole-foundation/example-native-token-transfers/pull/286 - // const transceiverIxs = encodeTransceiverInstructions([ - // { - // index: 0, - // payload: encodeWormholeTransceiverInstruction({ - // shouldSkipRelayerSend, - // }), - // }, - // ]); - const transceiverIxs = [ - { - index: 0, - payload: encodeWormholeTransceiverInstruction({ - shouldSkipRelayerSend: false, - }), - }, - ]; - const [, deliveryPrice] = await this.nttManager.quoteDeliveryPrice( - toChainId(destChain), - transceiverIxs, - [wormholeTransceiver], - ); - return deliveryPrice.toString(); + const { abi, version } = await this.getManagerAbi(); + if (isAbiVersion_0_1_0(version, abi)) { + const transceiverIxs = encodeTransceiverInstructions([ + { + index: 0, + payload: encodeWormholeTransceiverInstruction({ + shouldSkipRelayerSend: false, + }), + }, + ]); + const [, deliveryPrice] = await abi.quoteDeliveryPrice( + toChainId(destChain), + transceiverIxs, + ); + return deliveryPrice.toString(); + } else { + const transceiverIxs = [ + { + index: 0, + payload: encodeWormholeTransceiverInstruction({ + shouldSkipRelayerSend: false, + }), + }, + ]; + const [, deliveryPrice] = await ( + abi as NttManager_testnet + ).quoteDeliveryPrice(toChainId(destChain), transceiverIxs, [ + wormholeTransceiver, + ]); + return deliveryPrice.toString(); + } } async send( @@ -91,8 +105,9 @@ export class NttManagerEvm { ): Promise { const tokenConfig = getTokenById(token); if (!tokenConfig) throw new Error('token not found'); + const { abi } = await this.getManagerAbi(); const nttConfig = getNttManagerConfigByAddress( - this.nttManager.address, + this.address, toChainName(this.chain), ); if (!nttConfig || nttConfig.transceivers[0].type !== 'wormhole') @@ -111,7 +126,7 @@ export class NttManagerEvm { }), }, ]); - const tx = await this.nttManager.populateTransaction[ + const tx = await abi.populateTransaction[ 'transfer(uint256,uint16,bytes32,bool,bytes)' ]( amount, @@ -124,41 +139,38 @@ export class NttManagerEvm { const context = config.wh.getContext( this.chain, ) as EthContext; - await context.approve( - this.chain, - this.nttManager.address, - token.address, - amount, - ); + await context.approve(this.chain, this.address, token.address, amount); try { return await this.signAndSendTransaction(tx, TransferWallet.SENDING); } catch (e: any) { - this.throwParsedError(e); + this.throwParsedError(abi.interface, e); } } async getCurrentOutboundCapacity(): Promise { - return (await this.nttManager.getCurrentOutboundCapacity()).toString(); + const { abi } = await this.getManagerAbi(); + return (await abi.getCurrentOutboundCapacity()).toString(); } async getCurrentInboundCapacity( fromChain: ChainName | ChainId, ): Promise { + const { abi } = await this.getManagerAbi(); return ( - await this.nttManager.getCurrentInboundCapacity(toChainId(fromChain)) + await abi.getCurrentInboundCapacity(toChainId(fromChain)) ).toString(); } async getRateLimitDuration(): Promise { - return (await this.nttManager.rateLimitDuration()).toNumber(); + const { abi } = await this.getManagerAbi(); + return (await abi.rateLimitDuration()).toNumber(); } async getInboundQueuedTransfer( messageDigest: string, ): Promise { - const queuedTransfer = await this.nttManager.getInboundQueuedTransfer( - messageDigest, - ); + const { abi } = await this.getManagerAbi(); + const queuedTransfer = await abi.getInboundQueuedTransfer(messageDigest); if (queuedTransfer.txTimestamp.gt(0)) { const { recipient, amount, txTimestamp } = queuedTransfer; const duration = await this.getRateLimitDuration(); @@ -176,22 +188,21 @@ export class NttManagerEvm { recipient: string, payer: string, ): Promise { + const { abi } = await this.getManagerAbi(); try { - const tx = - await this.nttManager.populateTransaction.completeInboundQueuedTransfer( - messageDigest, - ); + const tx = await abi.populateTransaction.completeInboundQueuedTransfer( + messageDigest, + ); return await this.signAndSendTransaction(tx, TransferWallet.RECEIVING); } catch (e) { - this.throwParsedError(e); + this.throwParsedError(abi.interface, e); } } // The transfer is "complete" when the message is executed and not inbound queued async isTransferCompleted(messageDigest: string): Promise { - const isMessageExecuted = await this.nttManager.isMessageExecuted( - messageDigest, - ); + const { abi } = await this.getManagerAbi(); + const isMessageExecuted = await abi.isMessageExecuted(messageDigest); if (isMessageExecuted) { const queuedTransfer = await this.getInboundQueuedTransfer(messageDigest); return !queuedTransfer; @@ -200,24 +211,26 @@ export class NttManagerEvm { } async isPaused(): Promise { - return await this.nttManager.isPaused(); + const { abi } = await this.getManagerAbi(); + return await abi.isPaused(); } async fetchRedeemTx(messageDigest: string): Promise { - const eventFilter = this.nttManager.filters.TransferRedeemed(messageDigest); + const { abi } = await this.getManagerAbi(); + const eventFilter = abi.filters.TransferRedeemed(messageDigest); const provider = config.wh.mustGetProvider(this.chain); const currentBlock = await provider.getBlockNumber(); const chainName = toChainName(this.chain); const chainConfig = config.chains[chainName]!; - const events = await this.nttManager.queryFilter( + const events = await abi.queryFilter( eventFilter, currentBlock - chainConfig.maxBlockSearch, ); return events?.[0]?.transactionHash || undefined; } - throwParsedError(e: any): never { - const message = tryParseErrorMessage(this.nttManager.interface, e); + throwParsedError(iface: ethers.utils.Interface, e: any): never { + const message = tryParseErrorMessage(iface, e); if (message === 'InboundQueuedTransferNotFound') { throw new InboundQueuedTransferNotFoundError(); } @@ -232,4 +245,53 @@ export class NttManagerEvm { } throw e; } + + async getManagerAbi(): Promise<{ + abi: NttManager_0_1_0 | NttManager_testnet; + version: string; + }> { + const provider = config.wh.mustGetProvider(this.chain); + // Note: Special case for testnet + if (!config.isMainnet) { + return { + abi: NttManager__factory_testnet.connect(this.address, provider), + version: 'testnet', + }; + } + const abiVersionKey = `${this.address}-${toChainName(this.chain)}`; + let abiVersion = NttManagerEvm.abiVersionCache.get(abiVersionKey); + if (!abiVersion) { + const contract = new ethers.Contract( + this.address, + ['function NTT_MANAGER_VERSION() public view returns (string)'], + provider, + ); + try { + abiVersion = await contract.NTT_MANAGER_VERSION(); + } catch (e) { + console.error( + `Failed to get NTT_MANAGER_VERSION from contract ${ + this.address + } on chain ${toChainName(this.chain)}`, + ); + throw e; + } + if (!abiVersion) { + throw new Error('NTT_MANAGER_VERSION not found'); + } + NttManagerEvm.abiVersionCache.set(abiVersionKey, abiVersion); + } + if (abiVersion === ABI_VERSION_0_1_0) { + return { + abi: NttManager__factory_0_1_0.connect(this.address, provider), + version: abiVersion, + }; + } + console.error( + `Unsupported NttManager version ${abiVersion} for chain ${toChainName( + this.chain, + )}`, + ); + throw new UnsupportedContractAbiVersion(); + } } diff --git a/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts index 9e8bc4823..521e03f6b 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts @@ -1,38 +1,36 @@ import { ChainId, ChainName } from '@wormhole-foundation/wormhole-connect-sdk'; -import { WormholeTransceiver__factory } from './abis/WormholeTransceiver__factory'; +import { WormholeTransceiver__factory as WormholeTransceiver__factory_0_1_0 } from './abis/0.1.0/WormholeTransceiver__factory'; +import { WormholeTransceiver as WormholeTransceiver_0_1_0 } from './abis/0.1.0/WormholeTransceiver'; import { TransferWallet, signAndSendTransaction } from 'utils/wallet'; -import { WormholeTransceiver as WormholeTransceiverAbi } from './abis/WormholeTransceiver'; import config from 'config'; import { toChainId, toChainName } from 'utils/sdk'; +import { ethers } from 'ethers'; +import { UnsupportedContractAbiVersion } from 'routes/ntt/errors'; + +const ABI_VERSION_0_1_0 = '0.1.0'; export class WormholeTransceiver { - readonly transceiver: WormholeTransceiverAbi; + static readonly abiVersionCache = new Map(); - constructor(readonly chain: ChainName | ChainId, address: string) { - this.transceiver = WormholeTransceiver__factory.connect( - address, - config.wh.mustGetProvider(chain), - ); - } + constructor(readonly chain: ChainName | ChainId, readonly address: string) {} async isWormholeRelayingEnabled( destChain: ChainName | ChainId, ): Promise { - return await this.transceiver.isWormholeRelayingEnabled( - toChainId(destChain), - ); + const { abi } = await this.getAbi(); + return await abi.isWormholeRelayingEnabled(toChainId(destChain)); } async isSpecialRelayingEnabled( destChain: ChainName | ChainId, ): Promise { - return await this.transceiver.isSpecialRelayingEnabled( - toChainId(destChain), - ); + const { abi } = await this.getAbi(); + return await abi.isSpecialRelayingEnabled(toChainId(destChain)); } async receiveMessage(vaa: string, payer: string): Promise { - const tx = await this.transceiver.populateTransaction.receiveMessage(vaa); + const { abi } = await this.getAbi(); + const tx = await abi.populateTransaction.receiveMessage(vaa); const signer = await config.wh.mustGetSigner(this.chain); const response = await signer.sendTransaction(tx); const receipt = await response.wait(); @@ -43,4 +41,55 @@ export class WormholeTransceiver { ); return txId; } + + async getAbi(): Promise<{ + abi: WormholeTransceiver_0_1_0; + version: string; + }> { + const provider = config.wh.mustGetProvider(this.chain); + // Note: Special case for testnet + if (!config.isMainnet) { + return { + abi: WormholeTransceiver__factory_0_1_0.connect(this.address, provider), + version: ABI_VERSION_0_1_0, + }; + } + const abiVersionKey = `${this.address}-${toChainName(this.chain)}`; + let abiVersion = WormholeTransceiver.abiVersionCache.get(abiVersionKey); + if (!abiVersion) { + const contract = new ethers.Contract( + this.address, + [ + 'function WORMHOLE_TRANSCEIVER_VERSION() public view returns (string)', + ], + provider, + ); + try { + abiVersion = await contract.WORMHOLE_TRANSCEIVER_VERSION(); + } catch (e) { + console.error( + `Failed to get WORMHOLE_TRANSCEIVER_VERSION from contract ${ + this.address + } on chain ${toChainName(this.chain)}`, + ); + throw e; + } + if (!abiVersion) { + throw new Error('WORMHOLE_TRANSCEIVER_VERSION not found'); + } + WormholeTransceiver.abiVersionCache.set(abiVersionKey, abiVersion); + } + if (abiVersion === ABI_VERSION_0_1_0) { + return { + abi: WormholeTransceiver__factory_0_1_0.connect(this.address, provider), + version: abiVersion, + }; + } + console.error( + `Unsupported WormholeTransceiver version ${abiVersion} for chain ${toChainName( + this.chain, + )}`, + ); + throw new UnsupportedContractAbiVersion(); + } } diff --git a/wormhole-connect/src/routes/ntt/errors.ts b/wormhole-connect/src/routes/ntt/errors.ts index ac1f459d4..651b82463 100644 --- a/wormhole-connect/src/routes/ntt/errors.ts +++ b/wormhole-connect/src/routes/ntt/errors.ts @@ -32,3 +32,10 @@ export class DestinationContractIsPausedError extends Error { super(DestinationContractIsPausedError.MESSAGE); } } + +export class UnsupportedContractAbiVersion extends Error { + static MESSAGE = 'Unsupported contract ABI version'; + constructor() { + super(UnsupportedContractAbiVersion.MESSAGE); + } +} diff --git a/wormhole-connect/src/routes/ntt/nttBase.ts b/wormhole-connect/src/routes/ntt/nttBase.ts index e5f7e1da8..861532b55 100644 --- a/wormhole-connect/src/routes/ntt/nttBase.ts +++ b/wormhole-connect/src/routes/ntt/nttBase.ts @@ -116,6 +116,14 @@ export abstract class NttBase extends BaseRoute { sourceChain: ChainName | ChainId, destChain: ChainName | ChainId, ): Promise { + // Note: Solana is currently disabled in mainnet + if ( + config.isMainnet && + (toChainName(sourceChain) === 'solana' || + toChainName(destChain) === 'solana') + ) { + return false; + } return await Promise.all([ this.isSupportedChain(toChainName(sourceChain)), this.isSupportedChain(toChainName(destChain)), diff --git a/wormhole-connect/src/views/Bridge/Send.tsx b/wormhole-connect/src/views/Bridge/Send.tsx index c0721a6d0..c6b19da06 100644 --- a/wormhole-connect/src/views/Bridge/Send.tsx +++ b/wormhole-connect/src/views/Bridge/Send.tsx @@ -43,6 +43,7 @@ import { DestinationContractIsPausedError, NotEnoughCapacityError, ContractIsPausedError, + UnsupportedContractAbiVersion, } from 'routes/ntt/errors'; const useStyles = makeStyles()((theme) => ({ @@ -171,6 +172,8 @@ function Send(props: { valid: boolean }) { : e?.message === ContractIsPausedError.MESSAGE || e?.message === DestinationContractIsPausedError.MESSAGE ? e.message + : e?.message === UnsupportedContractAbiVersion.MESSAGE + ? 'Unsupported contract ABI version' : 'Error with transfer, please try again', ); } diff --git a/wormhole-connect/src/views/Redeem/SendTo.tsx b/wormhole-connect/src/views/Redeem/SendTo.tsx index dec26313f..d6d46681d 100644 --- a/wormhole-connect/src/views/Redeem/SendTo.tsx +++ b/wormhole-connect/src/views/Redeem/SendTo.tsx @@ -222,9 +222,10 @@ function SendTo() { } catch (e: any) { if (e.message === ContractIsPausedError.MESSAGE) { setClaimError('The contract is paused, please try again later'); + } else { + setClaimError('Your claim has failed, please try again'); } setInProgress(false); - setClaimError('Your claim has failed, please try again'); console.error(e); } if (txId !== undefined) { From 4a315a755db4a1faf9f34d193302621837939f32 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Fri, 29 Mar 2024 17:27:18 -0500 Subject: [PATCH 09/17] Updated testnet addresses --- .../src/config/testnet/nttGroups.ts | 8 +- .../evm/abis/testnet/WormholeTransceiver.ts | 1446 ----------------- .../testnet/WormholeTransceiver__factory.ts | 1351 --------------- .../src/routes/ntt/chains/evm/nttManager.ts | 35 +- 4 files changed, 21 insertions(+), 2819 deletions(-) delete mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver.ts delete mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver__factory.ts diff --git a/wormhole-connect/src/config/testnet/nttGroups.ts b/wormhole-connect/src/config/testnet/nttGroups.ts index 7827fcf2b..d24184e91 100644 --- a/wormhole-connect/src/config/testnet/nttGroups.ts +++ b/wormhole-connect/src/config/testnet/nttGroups.ts @@ -65,22 +65,22 @@ export const TESTNET_NTT_GROUPS: NttGroups = { nttManagers: [ { chainName: 'sepolia', - address: '0xFCD6994bC89FCB5891404Eb6268cFB3701F1C198', + address: '0x0e313085aa613df7594a524f5ea2e3f196f27e92', tokenKey: 'USDCsepolia', transceivers: [ { - address: '0xE18EF44f81fcF4ba3eD765F0B360B68f823Fac33', + address: '0x166F93EdAFCc5a183910658A9A31CE50e86E6007', type: 'wormhole', }, ], }, { chainName: 'alfajores', - address: '0x12594D5EBF88Deb5b02a6B7d265B421f6EE2CbA6', + address: '0x262C73a06A8C71dc0e53233F66329101a672C716', tokenKey: 'USDCalfajores', transceivers: [ { - address: '0x328f1fa5f84f62177d1e04976FdC49aB07578cf0', + address: '0x5D701Aa5320EC86D13C4Bcc93BC2296b6557AeAF', type: 'wormhole', }, ], diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver.ts deleted file mode 100644 index 1ad1c067d..000000000 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver.ts +++ /dev/null @@ -1,1446 +0,0 @@ -/* Autogenerated file. Do not edit manually. */ -/* tslint:disable */ -/* eslint-disable */ -import type { - BaseContract, - BigNumber, - BigNumberish, - BytesLike, - CallOverrides, - ContractTransaction, - Overrides, - PayableOverrides, - PopulatedTransaction, - Signer, - utils, -} from 'ethers'; -import type { - FunctionFragment, - Result, - EventFragment, -} from '@ethersproject/abi'; -import type { Listener, Provider } from '@ethersproject/providers'; -import type { - TypedEventFilter, - TypedEvent, - TypedListener, - OnEvent, -} from '../common'; - -export declare namespace TransceiverStructs { - export type TransceiverMessageStruct = { - sourceNttManagerAddress: BytesLike; - recipientNttManagerAddress: BytesLike; - nttManagerPayload: BytesLike; - transceiverPayload: BytesLike; - }; - - export type TransceiverMessageStructOutput = [ - string, - string, - string, - string, - ] & { - sourceNttManagerAddress: string; - recipientNttManagerAddress: string; - nttManagerPayload: string; - transceiverPayload: string; - }; - - export type TransceiverInstructionStruct = { - index: BigNumberish; - payload: BytesLike; - }; - - export type TransceiverInstructionStructOutput = [number, string] & { - index: number; - payload: string; - }; -} - -export declare namespace IWormholeTransceiver { - export type WormholeTransceiverInstructionStruct = { - shouldSkipRelayerSend: boolean; - }; - - export type WormholeTransceiverInstructionStructOutput = [boolean] & { - shouldSkipRelayerSend: boolean; - }; -} - -export interface WormholeTransceiverInterface extends utils.Interface { - functions: { - 'consistencyLevel()': FunctionFragment; - 'encodeWormholeTransceiverInstruction((bool))': FunctionFragment; - 'gasLimit()': FunctionFragment; - 'getMigratesImmutables()': FunctionFragment; - 'getNttManagerOwner()': FunctionFragment; - 'getNttManagerToken()': FunctionFragment; - 'getWormholePeer(uint16)': FunctionFragment; - 'initialize()': FunctionFragment; - 'isPaused()': FunctionFragment; - 'isSpecialRelayingEnabled(uint16)': FunctionFragment; - 'isVAAConsumed(bytes32)': FunctionFragment; - 'isWormholeEvmChain(uint16)': FunctionFragment; - 'isWormholeRelayingEnabled(uint16)': FunctionFragment; - 'migrate()': FunctionFragment; - 'nttManager()': FunctionFragment; - 'nttManagerToken()': FunctionFragment; - 'owner()': FunctionFragment; - 'parseWormholeTransceiverInstruction(bytes)': FunctionFragment; - 'pauser()': FunctionFragment; - 'quoteDeliveryPrice(uint16,(uint8,bytes))': FunctionFragment; - 'receiveMessage(bytes)': FunctionFragment; - 'receiveWormholeMessages(bytes,bytes[],bytes32,uint16,bytes32)': FunctionFragment; - 'sendMessage(uint16,(uint8,bytes),bytes,bytes32)': FunctionFragment; - 'setIsSpecialRelayingEnabled(uint16,bool)': FunctionFragment; - 'setIsWormholeEvmChain(uint16,bool)': FunctionFragment; - 'setIsWormholeRelayingEnabled(uint16,bool)': FunctionFragment; - 'setWormholePeer(uint16,bytes32)': FunctionFragment; - 'specialRelayer()': FunctionFragment; - 'transferOwnership(address)': FunctionFragment; - 'transferPauserCapability(address)': FunctionFragment; - 'transferTransceiverOwnership(address)': FunctionFragment; - 'upgrade(address)': FunctionFragment; - 'wormhole()': FunctionFragment; - 'wormholeRelayer()': FunctionFragment; - }; - - getFunction( - nameOrSignatureOrTopic: - | 'consistencyLevel' - | 'encodeWormholeTransceiverInstruction' - | 'gasLimit' - | 'getMigratesImmutables' - | 'getNttManagerOwner' - | 'getNttManagerToken' - | 'getWormholePeer' - | 'initialize' - | 'isPaused' - | 'isSpecialRelayingEnabled' - | 'isVAAConsumed' - | 'isWormholeEvmChain' - | 'isWormholeRelayingEnabled' - | 'migrate' - | 'nttManager' - | 'nttManagerToken' - | 'owner' - | 'parseWormholeTransceiverInstruction' - | 'pauser' - | 'quoteDeliveryPrice' - | 'receiveMessage' - | 'receiveWormholeMessages' - | 'sendMessage' - | 'setIsSpecialRelayingEnabled' - | 'setIsWormholeEvmChain' - | 'setIsWormholeRelayingEnabled' - | 'setWormholePeer' - | 'specialRelayer' - | 'transferOwnership' - | 'transferPauserCapability' - | 'transferTransceiverOwnership' - | 'upgrade' - | 'wormhole' - | 'wormholeRelayer', - ): FunctionFragment; - - encodeFunctionData( - functionFragment: 'consistencyLevel', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'encodeWormholeTransceiverInstruction', - values: [IWormholeTransceiver.WormholeTransceiverInstructionStruct], - ): string; - encodeFunctionData(functionFragment: 'gasLimit', values?: undefined): string; - encodeFunctionData( - functionFragment: 'getMigratesImmutables', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'getNttManagerOwner', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'getNttManagerToken', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'getWormholePeer', - values: [BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'initialize', - values?: undefined, - ): string; - encodeFunctionData(functionFragment: 'isPaused', values?: undefined): string; - encodeFunctionData( - functionFragment: 'isSpecialRelayingEnabled', - values: [BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'isVAAConsumed', - values: [BytesLike], - ): string; - encodeFunctionData( - functionFragment: 'isWormholeEvmChain', - values: [BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'isWormholeRelayingEnabled', - values: [BigNumberish], - ): string; - encodeFunctionData(functionFragment: 'migrate', values?: undefined): string; - encodeFunctionData( - functionFragment: 'nttManager', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'nttManagerToken', - values?: undefined, - ): string; - encodeFunctionData(functionFragment: 'owner', values?: undefined): string; - encodeFunctionData( - functionFragment: 'parseWormholeTransceiverInstruction', - values: [BytesLike], - ): string; - encodeFunctionData(functionFragment: 'pauser', values?: undefined): string; - encodeFunctionData( - functionFragment: 'quoteDeliveryPrice', - values: [BigNumberish, TransceiverStructs.TransceiverInstructionStruct], - ): string; - encodeFunctionData( - functionFragment: 'receiveMessage', - values: [BytesLike], - ): string; - encodeFunctionData( - functionFragment: 'receiveWormholeMessages', - values: [BytesLike, BytesLike[], BytesLike, BigNumberish, BytesLike], - ): string; - encodeFunctionData( - functionFragment: 'sendMessage', - values: [ - BigNumberish, - TransceiverStructs.TransceiverInstructionStruct, - BytesLike, - BytesLike, - ], - ): string; - encodeFunctionData( - functionFragment: 'setIsSpecialRelayingEnabled', - values: [BigNumberish, boolean], - ): string; - encodeFunctionData( - functionFragment: 'setIsWormholeEvmChain', - values: [BigNumberish, boolean], - ): string; - encodeFunctionData( - functionFragment: 'setIsWormholeRelayingEnabled', - values: [BigNumberish, boolean], - ): string; - encodeFunctionData( - functionFragment: 'setWormholePeer', - values: [BigNumberish, BytesLike], - ): string; - encodeFunctionData( - functionFragment: 'specialRelayer', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'transferOwnership', - values: [string], - ): string; - encodeFunctionData( - functionFragment: 'transferPauserCapability', - values: [string], - ): string; - encodeFunctionData( - functionFragment: 'transferTransceiverOwnership', - values: [string], - ): string; - encodeFunctionData(functionFragment: 'upgrade', values: [string]): string; - encodeFunctionData(functionFragment: 'wormhole', values?: undefined): string; - encodeFunctionData( - functionFragment: 'wormholeRelayer', - values?: undefined, - ): string; - - decodeFunctionResult( - functionFragment: 'consistencyLevel', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'encodeWormholeTransceiverInstruction', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'gasLimit', data: BytesLike): Result; - decodeFunctionResult( - functionFragment: 'getMigratesImmutables', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'getNttManagerOwner', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'getNttManagerToken', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'getWormholePeer', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result; - decodeFunctionResult(functionFragment: 'isPaused', data: BytesLike): Result; - decodeFunctionResult( - functionFragment: 'isSpecialRelayingEnabled', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'isVAAConsumed', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'isWormholeEvmChain', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'isWormholeRelayingEnabled', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'migrate', data: BytesLike): Result; - decodeFunctionResult(functionFragment: 'nttManager', data: BytesLike): Result; - decodeFunctionResult( - functionFragment: 'nttManagerToken', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; - decodeFunctionResult( - functionFragment: 'parseWormholeTransceiverInstruction', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'pauser', data: BytesLike): Result; - decodeFunctionResult( - functionFragment: 'quoteDeliveryPrice', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'receiveMessage', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'receiveWormholeMessages', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'sendMessage', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'setIsSpecialRelayingEnabled', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'setIsWormholeEvmChain', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'setIsWormholeRelayingEnabled', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'setWormholePeer', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'specialRelayer', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'transferOwnership', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'transferPauserCapability', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'transferTransceiverOwnership', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'upgrade', data: BytesLike): Result; - decodeFunctionResult(functionFragment: 'wormhole', data: BytesLike): Result; - decodeFunctionResult( - functionFragment: 'wormholeRelayer', - data: BytesLike, - ): Result; - - events: { - 'AdminChanged(address,address)': EventFragment; - 'BeaconUpgraded(address)': EventFragment; - 'Initialized(uint64)': EventFragment; - 'NotPaused(bool)': EventFragment; - 'OwnershipTransferred(address,address)': EventFragment; - 'Paused(bool)': EventFragment; - 'PauserTransferred(address,address)': EventFragment; - 'ReceivedMessage(bytes32,uint16,bytes32,uint64)': EventFragment; - 'ReceivedRelayedMessage(bytes32,uint16,bytes32)': EventFragment; - 'RelayingInfo(uint8,uint256)': EventFragment; - 'SendTransceiverMessage(uint16,(bytes32,bytes32,bytes,bytes))': EventFragment; - 'SetIsSpecialRelayingEnabled(uint16,bool)': EventFragment; - 'SetIsWormholeEvmChain(uint16,bool)': EventFragment; - 'SetIsWormholeRelayingEnabled(uint16,bool)': EventFragment; - 'SetWormholePeer(uint16,bytes32)': EventFragment; - 'Upgraded(address)': EventFragment; - }; - - getEvent(nameOrSignatureOrTopic: 'AdminChanged'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'BeaconUpgraded'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'NotPaused'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'PauserTransferred'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'ReceivedMessage'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'ReceivedRelayedMessage'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'RelayingInfo'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'SendTransceiverMessage'): EventFragment; - getEvent( - nameOrSignatureOrTopic: 'SetIsSpecialRelayingEnabled', - ): EventFragment; - getEvent(nameOrSignatureOrTopic: 'SetIsWormholeEvmChain'): EventFragment; - getEvent( - nameOrSignatureOrTopic: 'SetIsWormholeRelayingEnabled', - ): EventFragment; - getEvent(nameOrSignatureOrTopic: 'SetWormholePeer'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'Upgraded'): EventFragment; -} - -export interface AdminChangedEventObject { - previousAdmin: string; - newAdmin: string; -} -export type AdminChangedEvent = TypedEvent< - [string, string], - AdminChangedEventObject ->; - -export type AdminChangedEventFilter = TypedEventFilter; - -export interface BeaconUpgradedEventObject { - beacon: string; -} -export type BeaconUpgradedEvent = TypedEvent< - [string], - BeaconUpgradedEventObject ->; - -export type BeaconUpgradedEventFilter = TypedEventFilter; - -export interface InitializedEventObject { - version: BigNumber; -} -export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>; - -export type InitializedEventFilter = TypedEventFilter; - -export interface NotPausedEventObject { - notPaused: boolean; -} -export type NotPausedEvent = TypedEvent<[boolean], NotPausedEventObject>; - -export type NotPausedEventFilter = TypedEventFilter; - -export interface OwnershipTransferredEventObject { - previousOwner: string; - newOwner: string; -} -export type OwnershipTransferredEvent = TypedEvent< - [string, string], - OwnershipTransferredEventObject ->; - -export type OwnershipTransferredEventFilter = - TypedEventFilter; - -export interface PausedEventObject { - paused: boolean; -} -export type PausedEvent = TypedEvent<[boolean], PausedEventObject>; - -export type PausedEventFilter = TypedEventFilter; - -export interface PauserTransferredEventObject { - oldPauser: string; - newPauser: string; -} -export type PauserTransferredEvent = TypedEvent< - [string, string], - PauserTransferredEventObject ->; - -export type PauserTransferredEventFilter = - TypedEventFilter; - -export interface ReceivedMessageEventObject { - digest: string; - emitterChainId: number; - emitterAddress: string; - sequence: BigNumber; -} -export type ReceivedMessageEvent = TypedEvent< - [string, number, string, BigNumber], - ReceivedMessageEventObject ->; - -export type ReceivedMessageEventFilter = TypedEventFilter; - -export interface ReceivedRelayedMessageEventObject { - digest: string; - emitterChainId: number; - emitterAddress: string; -} -export type ReceivedRelayedMessageEvent = TypedEvent< - [string, number, string], - ReceivedRelayedMessageEventObject ->; - -export type ReceivedRelayedMessageEventFilter = - TypedEventFilter; - -export interface RelayingInfoEventObject { - relayingType: number; - deliveryPayment: BigNumber; -} -export type RelayingInfoEvent = TypedEvent< - [number, BigNumber], - RelayingInfoEventObject ->; - -export type RelayingInfoEventFilter = TypedEventFilter; - -export interface SendTransceiverMessageEventObject { - recipientChain: number; - message: TransceiverStructs.TransceiverMessageStructOutput; -} -export type SendTransceiverMessageEvent = TypedEvent< - [number, TransceiverStructs.TransceiverMessageStructOutput], - SendTransceiverMessageEventObject ->; - -export type SendTransceiverMessageEventFilter = - TypedEventFilter; - -export interface SetIsSpecialRelayingEnabledEventObject { - chainId: number; - isRelayingEnabled: boolean; -} -export type SetIsSpecialRelayingEnabledEvent = TypedEvent< - [number, boolean], - SetIsSpecialRelayingEnabledEventObject ->; - -export type SetIsSpecialRelayingEnabledEventFilter = - TypedEventFilter; - -export interface SetIsWormholeEvmChainEventObject { - chainId: number; - isEvm: boolean; -} -export type SetIsWormholeEvmChainEvent = TypedEvent< - [number, boolean], - SetIsWormholeEvmChainEventObject ->; - -export type SetIsWormholeEvmChainEventFilter = - TypedEventFilter; - -export interface SetIsWormholeRelayingEnabledEventObject { - chainId: number; - isRelayingEnabled: boolean; -} -export type SetIsWormholeRelayingEnabledEvent = TypedEvent< - [number, boolean], - SetIsWormholeRelayingEnabledEventObject ->; - -export type SetIsWormholeRelayingEnabledEventFilter = - TypedEventFilter; - -export interface SetWormholePeerEventObject { - chainId: number; - peerContract: string; -} -export type SetWormholePeerEvent = TypedEvent< - [number, string], - SetWormholePeerEventObject ->; - -export type SetWormholePeerEventFilter = TypedEventFilter; - -export interface UpgradedEventObject { - implementation: string; -} -export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; - -export type UpgradedEventFilter = TypedEventFilter; - -export interface WormholeTransceiver extends BaseContract { - connect(signerOrProvider: Signer | Provider | string): this; - attach(addressOrName: string): this; - deployed(): Promise; - - interface: WormholeTransceiverInterface; - - queryFilter( - event: TypedEventFilter, - fromBlockOrBlockhash?: string | number | undefined, - toBlock?: string | number | undefined, - ): Promise>; - - listeners( - eventFilter?: TypedEventFilter, - ): Array>; - listeners(eventName?: string): Array; - removeAllListeners( - eventFilter: TypedEventFilter, - ): this; - removeAllListeners(eventName?: string): this; - off: OnEvent; - on: OnEvent; - once: OnEvent; - removeListener: OnEvent; - - functions: { - consistencyLevel(overrides?: CallOverrides): Promise<[number]>; - - encodeWormholeTransceiverInstruction( - instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise<[string]>; - - gasLimit(overrides?: CallOverrides): Promise<[BigNumber]>; - - getMigratesImmutables(overrides?: CallOverrides): Promise<[boolean]>; - - getNttManagerOwner(overrides?: CallOverrides): Promise<[string]>; - - getNttManagerToken(overrides?: CallOverrides): Promise<[string]>; - - getWormholePeer( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise<[string]>; - - initialize( - overrides?: Overrides & { from?: string }, - ): Promise; - - isPaused(overrides?: CallOverrides): Promise<[boolean]>; - - isSpecialRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise<[boolean]>; - - isVAAConsumed( - hash: BytesLike, - overrides?: CallOverrides, - ): Promise<[boolean]>; - - isWormholeEvmChain( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise<[boolean]>; - - isWormholeRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise<[boolean]>; - - migrate( - overrides?: Overrides & { from?: string }, - ): Promise; - - nttManager(overrides?: CallOverrides): Promise<[string]>; - - nttManagerToken(overrides?: CallOverrides): Promise<[string]>; - - owner(overrides?: CallOverrides): Promise<[string]>; - - parseWormholeTransceiverInstruction( - encoded: BytesLike, - overrides?: CallOverrides, - ): Promise< - [IWormholeTransceiver.WormholeTransceiverInstructionStructOutput] & { - instruction: IWormholeTransceiver.WormholeTransceiverInstructionStructOutput; - } - >; - - pauser(overrides?: CallOverrides): Promise<[string]>; - - quoteDeliveryPrice( - targetChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise<[BigNumber]>; - - receiveMessage( - encodedMessage: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - receiveWormholeMessages( - payload: BytesLike, - additionalMessages: BytesLike[], - sourceAddress: BytesLike, - sourceChain: BigNumberish, - deliveryHash: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - sendMessage( - recipientChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - nttManagerMessage: BytesLike, - recipientNttManagerAddress: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - setIsSpecialRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setIsWormholeEvmChain( - chainId: BigNumberish, - isEvm: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setIsWormholeRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setWormholePeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - specialRelayer(overrides?: CallOverrides): Promise<[string]>; - - transferOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferTransceiverOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - wormhole(overrides?: CallOverrides): Promise<[string]>; - - wormholeRelayer(overrides?: CallOverrides): Promise<[string]>; - }; - - consistencyLevel(overrides?: CallOverrides): Promise; - - encodeWormholeTransceiverInstruction( - instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise; - - gasLimit(overrides?: CallOverrides): Promise; - - getMigratesImmutables(overrides?: CallOverrides): Promise; - - getNttManagerOwner(overrides?: CallOverrides): Promise; - - getNttManagerToken(overrides?: CallOverrides): Promise; - - getWormholePeer( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - initialize( - overrides?: Overrides & { from?: string }, - ): Promise; - - isPaused(overrides?: CallOverrides): Promise; - - isSpecialRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - isVAAConsumed(hash: BytesLike, overrides?: CallOverrides): Promise; - - isWormholeEvmChain( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - isWormholeRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - migrate( - overrides?: Overrides & { from?: string }, - ): Promise; - - nttManager(overrides?: CallOverrides): Promise; - - nttManagerToken(overrides?: CallOverrides): Promise; - - owner(overrides?: CallOverrides): Promise; - - parseWormholeTransceiverInstruction( - encoded: BytesLike, - overrides?: CallOverrides, - ): Promise; - - pauser(overrides?: CallOverrides): Promise; - - quoteDeliveryPrice( - targetChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise; - - receiveMessage( - encodedMessage: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - receiveWormholeMessages( - payload: BytesLike, - additionalMessages: BytesLike[], - sourceAddress: BytesLike, - sourceChain: BigNumberish, - deliveryHash: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - sendMessage( - recipientChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - nttManagerMessage: BytesLike, - recipientNttManagerAddress: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - setIsSpecialRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setIsWormholeEvmChain( - chainId: BigNumberish, - isEvm: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setIsWormholeRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setWormholePeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - specialRelayer(overrides?: CallOverrides): Promise; - - transferOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferTransceiverOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - wormhole(overrides?: CallOverrides): Promise; - - wormholeRelayer(overrides?: CallOverrides): Promise; - - callStatic: { - consistencyLevel(overrides?: CallOverrides): Promise; - - encodeWormholeTransceiverInstruction( - instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise; - - gasLimit(overrides?: CallOverrides): Promise; - - getMigratesImmutables(overrides?: CallOverrides): Promise; - - getNttManagerOwner(overrides?: CallOverrides): Promise; - - getNttManagerToken(overrides?: CallOverrides): Promise; - - getWormholePeer( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - initialize(overrides?: CallOverrides): Promise; - - isPaused(overrides?: CallOverrides): Promise; - - isSpecialRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - isVAAConsumed(hash: BytesLike, overrides?: CallOverrides): Promise; - - isWormholeEvmChain( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - isWormholeRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - migrate(overrides?: CallOverrides): Promise; - - nttManager(overrides?: CallOverrides): Promise; - - nttManagerToken(overrides?: CallOverrides): Promise; - - owner(overrides?: CallOverrides): Promise; - - parseWormholeTransceiverInstruction( - encoded: BytesLike, - overrides?: CallOverrides, - ): Promise; - - pauser(overrides?: CallOverrides): Promise; - - quoteDeliveryPrice( - targetChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise; - - receiveMessage( - encodedMessage: BytesLike, - overrides?: CallOverrides, - ): Promise; - - receiveWormholeMessages( - payload: BytesLike, - additionalMessages: BytesLike[], - sourceAddress: BytesLike, - sourceChain: BigNumberish, - deliveryHash: BytesLike, - overrides?: CallOverrides, - ): Promise; - - sendMessage( - recipientChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - nttManagerMessage: BytesLike, - recipientNttManagerAddress: BytesLike, - overrides?: CallOverrides, - ): Promise; - - setIsSpecialRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: CallOverrides, - ): Promise; - - setIsWormholeEvmChain( - chainId: BigNumberish, - isEvm: boolean, - overrides?: CallOverrides, - ): Promise; - - setIsWormholeRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: CallOverrides, - ): Promise; - - setWormholePeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - overrides?: CallOverrides, - ): Promise; - - specialRelayer(overrides?: CallOverrides): Promise; - - transferOwnership( - newOwner: string, - overrides?: CallOverrides, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: CallOverrides, - ): Promise; - - transferTransceiverOwnership( - newOwner: string, - overrides?: CallOverrides, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: CallOverrides, - ): Promise; - - wormhole(overrides?: CallOverrides): Promise; - - wormholeRelayer(overrides?: CallOverrides): Promise; - }; - - filters: { - 'AdminChanged(address,address)'( - previousAdmin?: null, - newAdmin?: null, - ): AdminChangedEventFilter; - AdminChanged( - previousAdmin?: null, - newAdmin?: null, - ): AdminChangedEventFilter; - - 'BeaconUpgraded(address)'( - beacon?: string | null, - ): BeaconUpgradedEventFilter; - BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter; - - 'Initialized(uint64)'(version?: null): InitializedEventFilter; - Initialized(version?: null): InitializedEventFilter; - - 'NotPaused(bool)'(notPaused?: null): NotPausedEventFilter; - NotPaused(notPaused?: null): NotPausedEventFilter; - - 'OwnershipTransferred(address,address)'( - previousOwner?: string | null, - newOwner?: string | null, - ): OwnershipTransferredEventFilter; - OwnershipTransferred( - previousOwner?: string | null, - newOwner?: string | null, - ): OwnershipTransferredEventFilter; - - 'Paused(bool)'(paused?: null): PausedEventFilter; - Paused(paused?: null): PausedEventFilter; - - 'PauserTransferred(address,address)'( - oldPauser?: string | null, - newPauser?: string | null, - ): PauserTransferredEventFilter; - PauserTransferred( - oldPauser?: string | null, - newPauser?: string | null, - ): PauserTransferredEventFilter; - - 'ReceivedMessage(bytes32,uint16,bytes32,uint64)'( - digest?: null, - emitterChainId?: null, - emitterAddress?: null, - sequence?: null, - ): ReceivedMessageEventFilter; - ReceivedMessage( - digest?: null, - emitterChainId?: null, - emitterAddress?: null, - sequence?: null, - ): ReceivedMessageEventFilter; - - 'ReceivedRelayedMessage(bytes32,uint16,bytes32)'( - digest?: null, - emitterChainId?: null, - emitterAddress?: null, - ): ReceivedRelayedMessageEventFilter; - ReceivedRelayedMessage( - digest?: null, - emitterChainId?: null, - emitterAddress?: null, - ): ReceivedRelayedMessageEventFilter; - - 'RelayingInfo(uint8,uint256)'( - relayingType?: null, - deliveryPayment?: null, - ): RelayingInfoEventFilter; - RelayingInfo( - relayingType?: null, - deliveryPayment?: null, - ): RelayingInfoEventFilter; - - 'SendTransceiverMessage(uint16,(bytes32,bytes32,bytes,bytes))'( - recipientChain?: null, - message?: null, - ): SendTransceiverMessageEventFilter; - SendTransceiverMessage( - recipientChain?: null, - message?: null, - ): SendTransceiverMessageEventFilter; - - 'SetIsSpecialRelayingEnabled(uint16,bool)'( - chainId?: null, - isRelayingEnabled?: null, - ): SetIsSpecialRelayingEnabledEventFilter; - SetIsSpecialRelayingEnabled( - chainId?: null, - isRelayingEnabled?: null, - ): SetIsSpecialRelayingEnabledEventFilter; - - 'SetIsWormholeEvmChain(uint16,bool)'( - chainId?: null, - isEvm?: null, - ): SetIsWormholeEvmChainEventFilter; - SetIsWormholeEvmChain( - chainId?: null, - isEvm?: null, - ): SetIsWormholeEvmChainEventFilter; - - 'SetIsWormholeRelayingEnabled(uint16,bool)'( - chainId?: null, - isRelayingEnabled?: null, - ): SetIsWormholeRelayingEnabledEventFilter; - SetIsWormholeRelayingEnabled( - chainId?: null, - isRelayingEnabled?: null, - ): SetIsWormholeRelayingEnabledEventFilter; - - 'SetWormholePeer(uint16,bytes32)'( - chainId?: null, - peerContract?: null, - ): SetWormholePeerEventFilter; - SetWormholePeer( - chainId?: null, - peerContract?: null, - ): SetWormholePeerEventFilter; - - 'Upgraded(address)'(implementation?: string | null): UpgradedEventFilter; - Upgraded(implementation?: string | null): UpgradedEventFilter; - }; - - estimateGas: { - consistencyLevel(overrides?: CallOverrides): Promise; - - encodeWormholeTransceiverInstruction( - instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise; - - gasLimit(overrides?: CallOverrides): Promise; - - getMigratesImmutables(overrides?: CallOverrides): Promise; - - getNttManagerOwner(overrides?: CallOverrides): Promise; - - getNttManagerToken(overrides?: CallOverrides): Promise; - - getWormholePeer( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - initialize(overrides?: Overrides & { from?: string }): Promise; - - isPaused(overrides?: CallOverrides): Promise; - - isSpecialRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - isVAAConsumed( - hash: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isWormholeEvmChain( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - isWormholeRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - migrate(overrides?: Overrides & { from?: string }): Promise; - - nttManager(overrides?: CallOverrides): Promise; - - nttManagerToken(overrides?: CallOverrides): Promise; - - owner(overrides?: CallOverrides): Promise; - - parseWormholeTransceiverInstruction( - encoded: BytesLike, - overrides?: CallOverrides, - ): Promise; - - pauser(overrides?: CallOverrides): Promise; - - quoteDeliveryPrice( - targetChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise; - - receiveMessage( - encodedMessage: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - receiveWormholeMessages( - payload: BytesLike, - additionalMessages: BytesLike[], - sourceAddress: BytesLike, - sourceChain: BigNumberish, - deliveryHash: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - sendMessage( - recipientChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - nttManagerMessage: BytesLike, - recipientNttManagerAddress: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - setIsSpecialRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setIsWormholeEvmChain( - chainId: BigNumberish, - isEvm: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setIsWormholeRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setWormholePeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - specialRelayer(overrides?: CallOverrides): Promise; - - transferOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferTransceiverOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - wormhole(overrides?: CallOverrides): Promise; - - wormholeRelayer(overrides?: CallOverrides): Promise; - }; - - populateTransaction: { - consistencyLevel(overrides?: CallOverrides): Promise; - - encodeWormholeTransceiverInstruction( - instruction: IWormholeTransceiver.WormholeTransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise; - - gasLimit(overrides?: CallOverrides): Promise; - - getMigratesImmutables( - overrides?: CallOverrides, - ): Promise; - - getNttManagerOwner( - overrides?: CallOverrides, - ): Promise; - - getNttManagerToken( - overrides?: CallOverrides, - ): Promise; - - getWormholePeer( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - initialize( - overrides?: Overrides & { from?: string }, - ): Promise; - - isPaused(overrides?: CallOverrides): Promise; - - isSpecialRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - isVAAConsumed( - hash: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isWormholeEvmChain( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - isWormholeRelayingEnabled( - chainId: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - migrate( - overrides?: Overrides & { from?: string }, - ): Promise; - - nttManager(overrides?: CallOverrides): Promise; - - nttManagerToken(overrides?: CallOverrides): Promise; - - owner(overrides?: CallOverrides): Promise; - - parseWormholeTransceiverInstruction( - encoded: BytesLike, - overrides?: CallOverrides, - ): Promise; - - pauser(overrides?: CallOverrides): Promise; - - quoteDeliveryPrice( - targetChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - overrides?: CallOverrides, - ): Promise; - - receiveMessage( - encodedMessage: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - receiveWormholeMessages( - payload: BytesLike, - additionalMessages: BytesLike[], - sourceAddress: BytesLike, - sourceChain: BigNumberish, - deliveryHash: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - sendMessage( - recipientChain: BigNumberish, - instruction: TransceiverStructs.TransceiverInstructionStruct, - nttManagerMessage: BytesLike, - recipientNttManagerAddress: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - setIsSpecialRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setIsWormholeEvmChain( - chainId: BigNumberish, - isEvm: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setIsWormholeRelayingEnabled( - chainId: BigNumberish, - isEnabled: boolean, - overrides?: Overrides & { from?: string }, - ): Promise; - - setWormholePeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - specialRelayer(overrides?: CallOverrides): Promise; - - transferOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferTransceiverOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - wormhole(overrides?: CallOverrides): Promise; - - wormholeRelayer(overrides?: CallOverrides): Promise; - }; -} diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver__factory.ts deleted file mode 100644 index a6783b4a5..000000000 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/WormholeTransceiver__factory.ts +++ /dev/null @@ -1,1351 +0,0 @@ -/* Autogenerated file. Do not edit manually. */ -/* tslint:disable */ -/* eslint-disable */ -import { - Signer, - utils, - Contract, - ContractFactory, - BigNumberish, - Overrides, -} from 'ethers'; -import type { Provider, TransactionRequest } from '@ethersproject/providers'; -import type { - WormholeTransceiver, - WormholeTransceiverInterface, -} from './WormholeTransceiver'; - -const _abi = [ - { - inputs: [ - { - internalType: 'address', - name: 'nttManager', - type: 'address', - }, - { - internalType: 'address', - name: 'wormholeCoreBridge', - type: 'address', - }, - { - internalType: 'address', - name: 'wormholeRelayerAddr', - type: 'address', - }, - { - internalType: 'address', - name: 'specialRelayerAddr', - type: 'address', - }, - { - internalType: 'uint8', - name: '_consistencyLevel', - type: 'uint8', - }, - { - internalType: 'uint256', - name: '_gasLimit', - type: 'uint256', - }, - ], - stateMutability: 'nonpayable', - type: 'constructor', - }, - { - inputs: [ - { - internalType: 'address', - name: 'caller', - type: 'address', - }, - ], - name: 'CallerNotNttManager', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'caller', - type: 'address', - }, - ], - name: 'CallerNotRelayer', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'currentOwner', - type: 'address', - }, - ], - name: 'CannotRenounceTransceiverOwnership', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'currentOwner', - type: 'address', - }, - { - internalType: 'address', - name: 'newOwner', - type: 'address', - }, - ], - name: 'CannotTransferTransceiverOwnership', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint8', - name: 'val', - type: 'uint8', - }, - ], - name: 'InvalidBoolVal', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'value', - type: 'uint256', - }, - ], - name: 'InvalidBoolValue', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'evmChainId', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'blockChainId', - type: 'uint256', - }, - ], - name: 'InvalidFork', - type: 'error', - }, - { - inputs: [], - name: 'InvalidInitialization', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'account', - type: 'address', - }, - ], - name: 'InvalidPauser', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - ], - name: 'InvalidRelayingConfig', - type: 'error', - }, - { - inputs: [ - { - internalType: 'string', - name: 'reason', - type: 'string', - }, - ], - name: 'InvalidVaa', - type: 'error', - }, - { - inputs: [], - name: 'InvalidWormholeChainIdZero', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'peerAddress', - type: 'bytes32', - }, - ], - name: 'InvalidWormholePeer', - type: 'error', - }, - { - inputs: [], - name: 'InvalidWormholePeerZeroAddress', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'encodedLength', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'expectedLength', - type: 'uint256', - }, - ], - name: 'LengthMismatch', - type: 'error', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: '', - type: 'bytes32', - }, - ], - name: 'NotAnEvmAddress', - type: 'error', - }, - { - inputs: [], - name: 'NotInitializing', - type: 'error', - }, - { - inputs: [], - name: 'NotMigrating', - type: 'error', - }, - { - inputs: [], - name: 'OnlyDelegateCall', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'owner', - type: 'address', - }, - ], - name: 'OwnableInvalidOwner', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'account', - type: 'address', - }, - ], - name: 'OwnableUnauthorizedAccount', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'peerAddress', - type: 'bytes32', - }, - ], - name: 'PeerAlreadySet', - type: 'error', - }, - { - inputs: [], - name: 'ReentrancyGuardReentrantCall', - type: 'error', - }, - { - inputs: [], - name: 'RequireContractIsNotPaused', - type: 'error', - }, - { - inputs: [], - name: 'RequireContractIsPaused', - type: 'error', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'vaaHash', - type: 'bytes32', - }, - ], - name: 'TransferAlreadyCompleted', - type: 'error', - }, - { - inputs: [], - name: 'UnexpectedAdditionalMessages', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'deployer', - type: 'address', - }, - { - internalType: 'address', - name: 'caller', - type: 'address', - }, - ], - name: 'UnexpectedDeployer', - type: 'error', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'recipientNttManagerAddress', - type: 'bytes32', - }, - { - internalType: 'bytes32', - name: 'expectedRecipientNttManagerAddress', - type: 'bytes32', - }, - ], - name: 'UnexpectedRecipientNttManagerAddress', - type: 'error', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'address', - name: 'previousAdmin', - type: 'address', - }, - { - indexed: false, - internalType: 'address', - name: 'newAdmin', - type: 'address', - }, - ], - name: 'AdminChanged', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'beacon', - type: 'address', - }, - ], - name: 'BeaconUpgraded', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint64', - name: 'version', - type: 'uint64', - }, - ], - name: 'Initialized', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bool', - name: 'notPaused', - type: 'bool', - }, - ], - name: 'NotPaused', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'previousOwner', - type: 'address', - }, - { - indexed: true, - internalType: 'address', - name: 'newOwner', - type: 'address', - }, - ], - name: 'OwnershipTransferred', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bool', - name: 'paused', - type: 'bool', - }, - ], - name: 'Paused', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'oldPauser', - type: 'address', - }, - { - indexed: true, - internalType: 'address', - name: 'newPauser', - type: 'address', - }, - ], - name: 'PauserTransferred', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - { - indexed: false, - internalType: 'uint16', - name: 'emitterChainId', - type: 'uint16', - }, - { - indexed: false, - internalType: 'bytes32', - name: 'emitterAddress', - type: 'bytes32', - }, - { - indexed: false, - internalType: 'uint64', - name: 'sequence', - type: 'uint64', - }, - ], - name: 'ReceivedMessage', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - { - indexed: false, - internalType: 'uint16', - name: 'emitterChainId', - type: 'uint16', - }, - { - indexed: false, - internalType: 'bytes32', - name: 'emitterAddress', - type: 'bytes32', - }, - ], - name: 'ReceivedRelayedMessage', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint8', - name: 'relayingType', - type: 'uint8', - }, - { - indexed: false, - internalType: 'uint256', - name: 'deliveryPayment', - type: 'uint256', - }, - ], - name: 'RelayingInfo', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint16', - name: 'recipientChain', - type: 'uint16', - }, - { - components: [ - { - internalType: 'bytes32', - name: 'sourceNttManagerAddress', - type: 'bytes32', - }, - { - internalType: 'bytes32', - name: 'recipientNttManagerAddress', - type: 'bytes32', - }, - { - internalType: 'bytes', - name: 'nttManagerPayload', - type: 'bytes', - }, - { - internalType: 'bytes', - name: 'transceiverPayload', - type: 'bytes', - }, - ], - indexed: false, - internalType: 'struct TransceiverStructs.TransceiverMessage', - name: 'message', - type: 'tuple', - }, - ], - name: 'SendTransceiverMessage', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - indexed: false, - internalType: 'bool', - name: 'isRelayingEnabled', - type: 'bool', - }, - ], - name: 'SetIsSpecialRelayingEnabled', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - indexed: false, - internalType: 'bool', - name: 'isEvm', - type: 'bool', - }, - ], - name: 'SetIsWormholeEvmChain', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - indexed: false, - internalType: 'bool', - name: 'isRelayingEnabled', - type: 'bool', - }, - ], - name: 'SetIsWormholeRelayingEnabled', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - indexed: false, - internalType: 'bytes32', - name: 'peerContract', - type: 'bytes32', - }, - ], - name: 'SetWormholePeer', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'implementation', - type: 'address', - }, - ], - name: 'Upgraded', - type: 'event', - }, - { - inputs: [], - name: 'consistencyLevel', - outputs: [ - { - internalType: 'uint8', - name: '', - type: 'uint8', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - components: [ - { - internalType: 'bool', - name: 'shouldSkipRelayerSend', - type: 'bool', - }, - ], - internalType: - 'struct IWormholeTransceiver.WormholeTransceiverInstruction', - name: 'instruction', - type: 'tuple', - }, - ], - name: 'encodeWormholeTransceiverInstruction', - outputs: [ - { - internalType: 'bytes', - name: '', - type: 'bytes', - }, - ], - stateMutability: 'pure', - type: 'function', - }, - { - inputs: [], - name: 'gasLimit', - outputs: [ - { - internalType: 'uint256', - name: '', - type: 'uint256', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getMigratesImmutables', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getNttManagerOwner', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getNttManagerToken', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - ], - name: 'getWormholePeer', - outputs: [ - { - internalType: 'bytes32', - name: '', - type: 'bytes32', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'initialize', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [], - name: 'isPaused', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - ], - name: 'isSpecialRelayingEnabled', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'hash', - type: 'bytes32', - }, - ], - name: 'isVAAConsumed', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - ], - name: 'isWormholeEvmChain', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - ], - name: 'isWormholeRelayingEnabled', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'migrate', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [], - name: 'nttManager', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'nttManagerToken', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'owner', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes', - name: 'encoded', - type: 'bytes', - }, - ], - name: 'parseWormholeTransceiverInstruction', - outputs: [ - { - components: [ - { - internalType: 'bool', - name: 'shouldSkipRelayerSend', - type: 'bool', - }, - ], - internalType: - 'struct IWormholeTransceiver.WormholeTransceiverInstruction', - name: 'instruction', - type: 'tuple', - }, - ], - stateMutability: 'pure', - type: 'function', - }, - { - inputs: [], - name: 'pauser', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'targetChain', - type: 'uint16', - }, - { - components: [ - { - internalType: 'uint8', - name: 'index', - type: 'uint8', - }, - { - internalType: 'bytes', - name: 'payload', - type: 'bytes', - }, - ], - internalType: 'struct TransceiverStructs.TransceiverInstruction', - name: 'instruction', - type: 'tuple', - }, - ], - name: 'quoteDeliveryPrice', - outputs: [ - { - internalType: 'uint256', - name: '', - type: 'uint256', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes', - name: 'encodedMessage', - type: 'bytes', - }, - ], - name: 'receiveMessage', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes', - name: 'payload', - type: 'bytes', - }, - { - internalType: 'bytes[]', - name: 'additionalMessages', - type: 'bytes[]', - }, - { - internalType: 'bytes32', - name: 'sourceAddress', - type: 'bytes32', - }, - { - internalType: 'uint16', - name: 'sourceChain', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'deliveryHash', - type: 'bytes32', - }, - ], - name: 'receiveWormholeMessages', - outputs: [], - stateMutability: 'payable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'recipientChain', - type: 'uint16', - }, - { - components: [ - { - internalType: 'uint8', - name: 'index', - type: 'uint8', - }, - { - internalType: 'bytes', - name: 'payload', - type: 'bytes', - }, - ], - internalType: 'struct TransceiverStructs.TransceiverInstruction', - name: 'instruction', - type: 'tuple', - }, - { - internalType: 'bytes', - name: 'nttManagerMessage', - type: 'bytes', - }, - { - internalType: 'bytes32', - name: 'recipientNttManagerAddress', - type: 'bytes32', - }, - ], - name: 'sendMessage', - outputs: [], - stateMutability: 'payable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - internalType: 'bool', - name: 'isEnabled', - type: 'bool', - }, - ], - name: 'setIsSpecialRelayingEnabled', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - internalType: 'bool', - name: 'isEvm', - type: 'bool', - }, - ], - name: 'setIsWormholeEvmChain', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - internalType: 'bool', - name: 'isEnabled', - type: 'bool', - }, - ], - name: 'setIsWormholeRelayingEnabled', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'peerChainId', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'peerContract', - type: 'bytes32', - }, - ], - name: 'setWormholePeer', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [], - name: 'specialRelayer', - outputs: [ - { - internalType: 'contract ISpecialRelayer', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'newOwner', - type: 'address', - }, - ], - name: 'transferOwnership', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'newPauser', - type: 'address', - }, - ], - name: 'transferPauserCapability', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'newOwner', - type: 'address', - }, - ], - name: 'transferTransceiverOwnership', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'newImplementation', - type: 'address', - }, - ], - name: 'upgrade', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [], - name: 'wormhole', - outputs: [ - { - internalType: 'contract IWormhole', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'wormholeRelayer', - outputs: [ - { - internalType: 'contract IWormholeRelayer', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, -] as const; - -const _bytecode = - '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__$93083e246e55d56d98f3df2872cd16bfd0$__906308a700d690610a24906309945ff160e41b908b9060040161322b565b600060405180830381865af4158015610a41573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610a699190810190613314565b81516020830151929450909250610a8391869190846116a4565b50505050505050565b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614610ad75760405163c5aa615360e01b81523360048201526024016108d0565b61077f816117a7565b610ae86113fc565b8161ffff16600003610b0d57604051630f7662c960e21b815260040160405180910390fd5b610b1681611631565b610b1e61153e565b61ffff841660008181526020928352604090819020939093558251908152831515918101919091527f528b18a533e892b5401d1fb63597275df9d2bb45b13e7695c3147cd07b9746c3910161087d565b6000610b78611818565b5460ff16919050565b610b896113fc565b8161ffff16600003610bae57604051630f7662c960e21b815260040160405180910390fd5b80610bcc5760405163137063ef60e11b815260040160405180910390fd5b6000610bd6611846565b61ffff84166000908152602091909152604090205490508015610c195760405163b55eeae960e01b815261ffff84166004820152602481018290526044016108d0565b81610c22611846565b61ffff858116600081815260209384526040808220959095558451606081018652630c7e33e160e11b8152938401918252838501878152945163077650fb60e51b815284516001600160e01b0319166004820152915190921660248201529251604484015290917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169163b19a437e9173__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$__90631185b23c90611c47906309945ff160e41b906001600160a01b038b16908a90899060248101613596565b600060405180830381865af4158015611c64573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611c8c91908101906135e2565b915091506000611c9f85602001516107af565b8051909150158015611cb55750611cb589612953565b15611dc3577f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316638fecdd02898b611cfc611cf78e61103d565b61296e565b8660007f00000000000000000000000000000000000000000000000000000000000000006040518763ffffffff1660e01b8152600401611d4095949392919061363b565b60206040518083038185885af1158015611d5e573d6000803e3d6000fd5b50505050506040513d601f19601f82011682018060405250810190611d839190613450565b506040805160008152602081018a90527f375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271910160405180910390a1612099565b8051158015611dd65750611dd689611130565b15611fa9576040516358cd21bf60e11b81526000906001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063b19a437e90611e4e90849087907f000000000000000000000000000000000000000000000000000000000000000090600401613407565b6020604051808303816000875af1158015611e6d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611e919190613450565b90506001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000166316ac49c28a7f00000000000000000000000000000000000000000000000000000000000000006040516001600160e01b031960e085901b1681526001600160a01b03909116600482015261ffff8e166024820152600060448201526001600160401b03851660648201526084016000604051808303818588803b158015611f4457600080fd5b505af1158015611f58573d6000803e3d6000fd5b507f375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271935060019250611f88915050565b6040805160ff9092168252602082018c90520160405180910390a150612099565b6040516358cd21bf60e11b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063b19a437e9061201a9060009086907f000000000000000000000000000000000000000000000000000000000000000090600401613407565b6020604051808303816000875af1158015612039573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061205d9190613450565b506040805160028152602081018a90527f375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271910160405180910390a15b7f79376a0dc6cbfe6f6f8f89ad24c262a8c6233f8df181d3fe5abb2e2442e8c73889846040516120ca92919061367d565b60405180910390a1505050505050505050565b60017f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f0055565b6000606060008060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663c0fd8bde876040518263ffffffff1660e01b8152600401612158919061307f565b600060405180830381865afa158015612175573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f1916820160405261219d91908101906137ad565b925092509250816121c35780604051634771719b60e11b81526004016108d0919061307f565b6121cc8361299a565b6121ff5760608301516080840151604051633cd8e72b60e11b815261ffff909216600483015260248201526044016108d0565b61220d836101400151610de4565b1561223457826101400151604051632d30ec0360e21b81526004016108d091815260200190565b61224283610140015161167c565b7ff6fc529540981400dc64edf649eb5e2e0eb5812a27f8c81bac2c1d317e71a5f0836101400151846060015185608001518660a001516040516122ab949392919093845261ffff92909216602084015260408301526001600160401b0316606082015260800190565b60405180910390a182606001518360e0015194509450505050915091565b6122d2816129de565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b612311612a8c565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316306001600160a01b03166384acd1bb6040518163ffffffff1660e01b8152600401602060405180830381865afa158015612379573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061239d91906134a1565b6001600160a01b0316146123b3576123b36134d1565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316306001600160a01b031663da25b7256040518163ffffffff1660e01b8152600401602060405180830381865afa15801561241b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061243f91906134a1565b6001600160a01b031614612455576124556134d1565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316306001600160a01b03166390ea54286040518163ffffffff1660e01b8152600401602060405180830381865afa1580156124bd573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906124e191906134a1565b6001600160a01b0316146124f7576124f76134d1565b7f000000000000000000000000000000000000000000000000000000000000000060ff16306001600160a01b031663e8dfd5086040518163ffffffff1660e01b8152600401602060405180830381865afa158015612559573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061257d9190613904565b60ff161461142e5761142e6134d1565b80612596611818565b805460ff191691151591909117905550565b336001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161461262257604051636345072160e11b81526001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001660048201523360248201526044016108d0565b61262a612bd0565b61142e3361263661113d565b612be0565b6040805160a08101909152639c23bd3b60e01b8152600090602081016001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001681526020017f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316634b4fd03b6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156126e4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906127089190613904565b60ff1681526020016001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001681526020017f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316633b97e8566040518163ffffffff1660e01b8152600401602060405180830381865afa15801561279d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906127c19190613904565b60ff908116909152604080516301529f6160e21b815283516001600160e01b031916600482015260208401516024820152908301518216604482015260608301516064820152608083015190911660848201529091506001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063b19a437e9060009073__$93083e246e55d56d98f3df2872cd16bfd0$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'; - -type WormholeTransceiverConstructorParams = - | [linkLibraryAddresses: WormholeTransceiverLibraryAddresses, signer?: Signer] - | ConstructorParameters; - -const isSuperArgs = ( - xs: WormholeTransceiverConstructorParams, -): 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 WormholeTransceiver__factory extends ContractFactory { - constructor(...args: WormholeTransceiverConstructorParams) { - if (isSuperArgs(args)) { - super(...args); - } else { - const [linkLibraryAddresses, signer] = args; - super( - _abi, - WormholeTransceiver__factory.linkBytecode(linkLibraryAddresses), - signer, - ); - } - } - - static linkBytecode( - linkLibraryAddresses: WormholeTransceiverLibraryAddresses, - ): string { - let linkedBytecode = _bytecode; - - linkedBytecode = linkedBytecode.replace( - new RegExp('__\\$93083e246e55d56d98f3df2872cd16bfd0\\$__', 'g'), - linkLibraryAddresses[ - 'src/libraries/TransceiverStructs.sol:TransceiverStructs' - ] - .replace(/^0x/, '') - .toLowerCase(), - ); - - return linkedBytecode; - } - - override deploy( - nttManager: string, - wormholeCoreBridge: string, - wormholeRelayerAddr: string, - specialRelayerAddr: string, - _consistencyLevel: BigNumberish, - _gasLimit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise { - return super.deploy( - nttManager, - wormholeCoreBridge, - wormholeRelayerAddr, - specialRelayerAddr, - _consistencyLevel, - _gasLimit, - overrides || {}, - ) as Promise; - } - override getDeployTransaction( - nttManager: string, - wormholeCoreBridge: string, - wormholeRelayerAddr: string, - specialRelayerAddr: string, - _consistencyLevel: BigNumberish, - _gasLimit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): TransactionRequest { - return super.getDeployTransaction( - nttManager, - wormholeCoreBridge, - wormholeRelayerAddr, - specialRelayerAddr, - _consistencyLevel, - _gasLimit, - overrides || {}, - ); - } - override attach(address: string): WormholeTransceiver { - return super.attach(address) as WormholeTransceiver; - } - override connect(signer: Signer): WormholeTransceiver__factory { - return super.connect(signer) as WormholeTransceiver__factory; - } - - static readonly bytecode = _bytecode; - static readonly abi = _abi; - static createInterface(): WormholeTransceiverInterface { - return new utils.Interface(_abi) as WormholeTransceiverInterface; - } - static connect( - address: string, - signerOrProvider: Signer | Provider, - ): WormholeTransceiver { - return new Contract(address, _abi, signerOrProvider) as WormholeTransceiver; - } -} - -export interface WormholeTransceiverLibraryAddresses { - ['src/libraries/TransceiverStructs.sol:TransceiverStructs']: string; -} diff --git a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts index 9a7dee0c1..624b56802 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts @@ -20,7 +20,6 @@ import { encodeTransceiverInstructions, encodeWormholeTransceiverInstruction, } from 'routes/ntt/utils'; -import { NttManager__factory as NttManager__factory_testnet } from './abis/testnet/NttManager__factory'; import { NttManager as NttManager_testnet } from './abis/testnet/NttManager'; import { NttManager__factory as NttManager__factory_0_1_0 } from './abis/0.1.0/NttManager__factory'; import { NttManager as NttManager_0_1_0 } from './abis/0.1.0/NttManager'; @@ -62,7 +61,7 @@ export class NttManagerEvm { destChain: ChainName | ChainId, wormholeTransceiver: string, ): Promise { - const { abi, version } = await this.getManagerAbi(); + const { abi, version } = await this.getAbi(); if (isAbiVersion_0_1_0(version, abi)) { const transceiverIxs = encodeTransceiverInstructions([ { @@ -105,7 +104,7 @@ export class NttManagerEvm { ): Promise { const tokenConfig = getTokenById(token); if (!tokenConfig) throw new Error('token not found'); - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); const nttConfig = getNttManagerConfigByAddress( this.address, toChainName(this.chain), @@ -148,28 +147,28 @@ export class NttManagerEvm { } async getCurrentOutboundCapacity(): Promise { - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); return (await abi.getCurrentOutboundCapacity()).toString(); } async getCurrentInboundCapacity( fromChain: ChainName | ChainId, ): Promise { - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); return ( await abi.getCurrentInboundCapacity(toChainId(fromChain)) ).toString(); } async getRateLimitDuration(): Promise { - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); return (await abi.rateLimitDuration()).toNumber(); } async getInboundQueuedTransfer( messageDigest: string, ): Promise { - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); const queuedTransfer = await abi.getInboundQueuedTransfer(messageDigest); if (queuedTransfer.txTimestamp.gt(0)) { const { recipient, amount, txTimestamp } = queuedTransfer; @@ -188,7 +187,7 @@ export class NttManagerEvm { recipient: string, payer: string, ): Promise { - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); try { const tx = await abi.populateTransaction.completeInboundQueuedTransfer( messageDigest, @@ -201,7 +200,7 @@ export class NttManagerEvm { // The transfer is "complete" when the message is executed and not inbound queued async isTransferCompleted(messageDigest: string): Promise { - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); const isMessageExecuted = await abi.isMessageExecuted(messageDigest); if (isMessageExecuted) { const queuedTransfer = await this.getInboundQueuedTransfer(messageDigest); @@ -211,12 +210,12 @@ export class NttManagerEvm { } async isPaused(): Promise { - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); return await abi.isPaused(); } async fetchRedeemTx(messageDigest: string): Promise { - const { abi } = await this.getManagerAbi(); + const { abi } = await this.getAbi(); const eventFilter = abi.filters.TransferRedeemed(messageDigest); const provider = config.wh.mustGetProvider(this.chain); const currentBlock = await provider.getBlockNumber(); @@ -246,18 +245,18 @@ export class NttManagerEvm { throw e; } - async getManagerAbi(): Promise<{ + async getAbi(): Promise<{ abi: NttManager_0_1_0 | NttManager_testnet; version: string; }> { const provider = config.wh.mustGetProvider(this.chain); // Note: Special case for testnet - if (!config.isMainnet) { - return { - abi: NttManager__factory_testnet.connect(this.address, provider), - version: 'testnet', - }; - } + //if (!config.isMainnet) { + // return { + // abi: NttManager__factory_testnet.connect(this.address, provider), + // version: 'testnet', + // }; + //} const abiVersionKey = `${this.address}-${toChainName(this.chain)}`; let abiVersion = NttManagerEvm.abiVersionCache.get(abiVersionKey); if (!abiVersion) { From 1e3606a53242031c808640a8577b1950cb65c12a Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Fri, 29 Mar 2024 18:04:27 -0500 Subject: [PATCH 10/17] updated testnet USDC.e address --- wormhole-connect/src/config/testnet/tokens.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wormhole-connect/src/config/testnet/tokens.ts b/wormhole-connect/src/config/testnet/tokens.ts index 72d859f47..258e63974 100644 --- a/wormhole-connect/src/config/testnet/tokens.ts +++ b/wormhole-connect/src/config/testnet/tokens.ts @@ -907,7 +907,7 @@ export const TESTNET_TOKENS: TokensConfig = { icon: Icon.USDC, tokenId: { chain: 'alfajores', - address: '0x4004d1EB4b65A38c65dc9575bEe3DfCb026Cb538', + address: '0xe00b745b5e71337507d43a8584320c4192CA7994', }, coinGeckoId: 'usd-coin', color: '#2774CA', From 2a18f29f7afeb6ca4306a80a9f6ef68a92525b2b Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Mon, 1 Apr 2024 09:59:10 -0500 Subject: [PATCH 11/17] rebased development --- package-lock.json | 17 +++++++++++++++++ .../src/config/testnet/nttGroups.ts | 7 +------ wormhole-connect/src/config/utils.ts | 11 +++++++++++ wormhole-connect/src/store/transferInput.ts | 8 ++++---- wormhole-connect/src/utils/ntt.ts | 4 ++-- .../src/views/Redeem/NttInboundQueued.tsx | 1 + wormhole-connect/src/views/Redeem/Redeem.tsx | 3 +-- .../src/views/Redeem/RelayerDeliveryFailed.tsx | 1 + 8 files changed, 38 insertions(+), 14 deletions(-) diff --git a/package-lock.json b/package-lock.json index 8f36744ac..b9288ad81 100644 --- a/package-lock.json +++ b/package-lock.json @@ -13978,6 +13978,23 @@ "node": ">= 6" } }, + "node_modules/@xlabs-libs/wallet-aggregator-evm": { + "version": "0.0.1-alpha.37", + "resolved": "https://registry.npmjs.org/@xlabs-libs/wallet-aggregator-evm/-/wallet-aggregator-evm-0.0.1-alpha.37.tgz", + "integrity": "sha512-mtkIyWJeirLWZ5YfLXvas4/0sp9t7TfcNZ2MPm+Sseq3VcZeuaLDd58NwLfh3S3QYatC3koT6pOK8OYlNG5f0Q==", + "dependencies": { + "@ethersproject/abi": "^5.7.0", + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/providers": "^5.7.2", + "@wagmi/core": "^1.4.13", + "@web3modal/standalone": "^2.2.1", + "@xlabs-libs/wallet-aggregator-core": "^0.0.1-alpha.18", + "ethers": "^5.7.2", + "versions": "^10.4.1", + "viem": "^1.20.3" + } + }, "node_modules/@xlabs-libs/wallet-aggregator-sei": { "version": "0.0.1-alpha.14", "resolved": "https://registry.npmjs.org/@xlabs-libs/wallet-aggregator-sei/-/wallet-aggregator-sei-0.0.1-alpha.14.tgz", diff --git a/wormhole-connect/src/config/testnet/nttGroups.ts b/wormhole-connect/src/config/testnet/nttGroups.ts index d24184e91..f38368a9a 100644 --- a/wormhole-connect/src/config/testnet/nttGroups.ts +++ b/wormhole-connect/src/config/testnet/nttGroups.ts @@ -51,12 +51,7 @@ export const TESTNET_NTT_GROUPS: NttGroups = { chainName: 'solana', address: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', tokenKey: 'TEST_NTTsolana', - transceivers: [ - { - address: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', - type: 'wormhole', - }, - ], + transceivers: [], solanaQuoter: 'NqTdGLLL6b6bFo7YESNEezocgF8onH5cst5EdH791en', }, ], diff --git a/wormhole-connect/src/config/utils.ts b/wormhole-connect/src/config/utils.ts index bd7c57e57..782adb398 100644 --- a/wormhole-connect/src/config/utils.ts +++ b/wormhole-connect/src/config/utils.ts @@ -126,6 +126,17 @@ export const mergeNttGroups = ( continue; } + // if any of the chain names in the custom group are duplicated, skip + if ( + new Set(customGroup.nttManagers.map((manager) => manager.chainName)) + .size !== customGroup.nttManagers.length + ) { + console.warn( + `Skipping custom NTT group config for "${key}" because it contains duplicate chain names`, + ); + continue; + } + console.info(`Accepted custom NTT group config for "${key}"`); builtin[key] = custom[key]; } diff --git a/wormhole-connect/src/store/transferInput.ts b/wormhole-connect/src/store/transferInput.ts index 3022e95b5..f4f14a412 100644 --- a/wormhole-connect/src/store/transferInput.ts +++ b/wormhole-connect/src/store/transferInput.ts @@ -186,8 +186,8 @@ const performModificationsIfFromChainChanged = (state: TransferInputState) => { } if (isNttRoute(route) && destToken) { const groupKey = getNttGroupKey(tokenConfig, config.tokens[destToken]); - if (groupKey) { - state.token = getNttTokenByGroupKey(groupKey, fromChain!)?.key || ''; + if (groupKey && fromChain) { + state.token = getNttTokenByGroupKey(groupKey, fromChain)?.key || ''; } else { state.token = ''; } @@ -222,8 +222,8 @@ const performModificationsIfToChainChanged = (state: TransferInputState) => { } if (isNttRoute(route) && token) { const groupKey = getNttGroupKey(tokenConfig, config.tokens[token]); - if (groupKey) { - state.destToken = getNttTokenByGroupKey(groupKey, toChain!)?.key || ''; + if (groupKey && toChain) { + state.destToken = getNttTokenByGroupKey(groupKey, toChain)?.key || ''; } else { state.destToken = ''; } diff --git a/wormhole-connect/src/utils/ntt.ts b/wormhole-connect/src/utils/ntt.ts index 34aa8e26b..d86737e85 100644 --- a/wormhole-connect/src/utils/ntt.ts +++ b/wormhole-connect/src/utils/ntt.ts @@ -102,14 +102,14 @@ export const getNttManagerConfigByAddress = ( isEqualCaseInsensitive(manager.address, managerAddress) && manager.chainName === chainName, ), - )[0]; + )?.[0]; }; export const getNttManagerConfigByGroupKey = ( groupKey: string, chainName: ChainName, ): NttManagerConfig | undefined => { - return config.nttGroups[groupKey].nttManagers.find( + return config.nttGroups[groupKey]?.nttManagers.find( (manager) => manager.chainName === chainName, ); }; diff --git a/wormhole-connect/src/views/Redeem/NttInboundQueued.tsx b/wormhole-connect/src/views/Redeem/NttInboundQueued.tsx index 0280e5e6a..ce58c17d1 100644 --- a/wormhole-connect/src/views/Redeem/NttInboundQueued.tsx +++ b/wormhole-connect/src/views/Redeem/NttInboundQueued.tsx @@ -151,6 +151,7 @@ const NttInboundQueued = () => {
{!expired ? (
diff --git a/wormhole-connect/src/views/Redeem/Redeem.tsx b/wormhole-connect/src/views/Redeem/Redeem.tsx index 090fa3d30..40b42f6ac 100644 --- a/wormhole-connect/src/views/Redeem/Redeem.tsx +++ b/wormhole-connect/src/views/Redeem/Redeem.tsx @@ -90,9 +90,8 @@ function Redeem({ while (signed === undefined && !cancelled) { try { signed = await RouteOperator.getSignedMessage(route, txData); - } catch (e) { + } catch { signed = undefined; - console.log(e); } if (cancelled) { return; diff --git a/wormhole-connect/src/views/Redeem/RelayerDeliveryFailed.tsx b/wormhole-connect/src/views/Redeem/RelayerDeliveryFailed.tsx index cc76e902b..4b10be521 100644 --- a/wormhole-connect/src/views/Redeem/RelayerDeliveryFailed.tsx +++ b/wormhole-connect/src/views/Redeem/RelayerDeliveryFailed.tsx @@ -37,6 +37,7 @@ const RelayerDeliveryFailed = () => { chain={txData.toChain} address={txData.recipient} txHash={redeemTx} + side="destination" />
From b0d63a801fd82864dc0b721168e9a23c9a0808ae Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Mon, 1 Apr 2024 16:52:53 -0500 Subject: [PATCH 12/17] updated 0.1.0 ABI, avax-celo addresses --- .../src/config/testnet/nttGroups.ts | 69 +- wormhole-connect/src/config/testnet/tokens.ts | 2 +- .../ntt/chains/evm/abis/0.1.0/NttManager.ts | 105 +- .../evm/abis/0.1.0/NttManager__factory.ts | 77 +- .../evm/abis/0.1.0/WormholeTransceiver.ts | 17 +- .../0.1.0/WormholeTransceiver__factory.ts | 13 +- .../ntt/chains/evm/abis/testnet/NttManager.ts | 1888 ----------------- .../evm/abis/testnet/NttManager__factory.ts | 1858 ---------------- .../src/routes/ntt/chains/evm/getMessage.ts | 4 +- .../src/routes/ntt/chains/evm/nttManager.ts | 88 +- .../ntt/chains/evm/wormholeTransceiver.ts | 7 - wormhole-connect/src/routes/ntt/nttRelay.ts | 5 +- wormhole-connect/src/routes/utils.ts | 2 +- 13 files changed, 227 insertions(+), 3908 deletions(-) delete mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager.ts delete mode 100644 wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager__factory.ts diff --git a/wormhole-connect/src/config/testnet/nttGroups.ts b/wormhole-connect/src/config/testnet/nttGroups.ts index f38368a9a..07d20d78d 100644 --- a/wormhole-connect/src/config/testnet/nttGroups.ts +++ b/wormhole-connect/src/config/testnet/nttGroups.ts @@ -1,81 +1,26 @@ import { NttGroups } from 'config/types'; export const TESTNET_NTT_GROUPS: NttGroups = { - TEST_NTT: { + USDC_NTT: { nttManagers: [ { - chainName: 'sepolia', - address: '0xB231aD95f2301bc82eA44c515001F0F746D637e0', - tokenKey: 'TEST_NTTsepolia', + chainName: 'fuji', + address: '0x22D00F8aCcC2da440c937104BA49AfD8261a660F', + tokenKey: 'USDCavax', transceivers: [ { - address: '0x1fDC902e30b188FD2BA976B421Cb179943F57896', - type: 'wormhole', - }, - ], - }, - { - chainName: 'arbitrum_sepolia', - address: '0xEec94CD3083e067398256a79CcA7e740C5c8ef81', - tokenKey: 'TEST_NTTarbitrum_sepolia', - transceivers: [ - { - address: '0x0E24D17D7467467b39Bf64A9DFf88776Bd6c74d7', - type: 'wormhole', - }, - ], - }, - { - chainName: 'base_sepolia', - address: '0xB03b030b2f5B40819Df76467d67eD1C85Ff66fAD', - tokenKey: 'TEST_NTTbase_sepolia', - transceivers: [ - { - address: '0x1e072169541f1171e427Aa44B5fd8924BEE71b0e', - type: 'wormhole', - }, - ], - }, - { - chainName: 'optimism_sepolia', - address: '0x7f430D4e7939D994C0955A01FC75D9DE33F12D11', - tokenKey: 'TEST_NTToptimism_sepolia', - transceivers: [ - { - address: '0x41265eb2863bf0238081F6AeefeF73549C82C3DD', - type: 'wormhole', - }, - ], - }, - { - chainName: 'solana', - address: 'nTTh3bZ5Aer6xboWZe39RDEft4MeVxSQ8D1EYAVLZw9', - tokenKey: 'TEST_NTTsolana', - transceivers: [], - solanaQuoter: 'NqTdGLLL6b6bFo7YESNEezocgF8onH5cst5EdH791en', - }, - ], - }, - TEST_USDC: { - nttManagers: [ - { - chainName: 'sepolia', - address: '0x0e313085aa613df7594a524f5ea2e3f196f27e92', - tokenKey: 'USDCsepolia', - transceivers: [ - { - address: '0x166F93EdAFCc5a183910658A9A31CE50e86E6007', + address: '0xeA8D34fa9147863e486d2d07AB92b8218CF58C0E', type: 'wormhole', }, ], }, { chainName: 'alfajores', - address: '0x262C73a06A8C71dc0e53233F66329101a672C716', + address: '0xdc86639219fD880A30C71B58E1cfA2707B645516', tokenKey: 'USDCalfajores', transceivers: [ { - address: '0x5D701Aa5320EC86D13C4Bcc93BC2296b6557AeAF', + address: '0x76516c0b966B4D4cFEFB107755562b16427dAE52', type: 'wormhole', }, ], diff --git a/wormhole-connect/src/config/testnet/tokens.ts b/wormhole-connect/src/config/testnet/tokens.ts index 258e63974..fcea2e9ff 100644 --- a/wormhole-connect/src/config/testnet/tokens.ts +++ b/wormhole-connect/src/config/testnet/tokens.ts @@ -907,7 +907,7 @@ export const TESTNET_TOKENS: TokensConfig = { icon: Icon.USDC, tokenId: { chain: 'alfajores', - address: '0xe00b745b5e71337507d43a8584320c4192CA7994', + address: '0x72CAaa7e9889E0a63e016748179b43911A3ec9e5', }, coinGeckoId: 'usd-coin', color: '#2774CA', diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager.ts index 2962c74c9..480fcd0bb 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager.ts @@ -72,6 +72,7 @@ export declare namespace IRateLimiter { export type OutboundQueuedTransferStruct = { recipient: BytesLike; + refundAddress: BytesLike; amount: BigNumberish; txTimestamp: BigNumberish; recipientChain: BigNumberish; @@ -80,6 +81,7 @@ export declare namespace IRateLimiter { }; export type OutboundQueuedTransferStructOutput = [ + string, string, BigNumber, BigNumber, @@ -88,6 +90,7 @@ export declare namespace IRateLimiter { string, ] & { recipient: string; + refundAddress: string; amount: BigNumber; txTimestamp: BigNumber; recipientChain: number; @@ -112,6 +115,7 @@ export interface NttManagerInterface extends utils.Interface { functions: { 'NTT_MANAGER_VERSION()': FunctionFragment; 'attestationReceived(uint16,bytes32,(bytes32,bytes32,bytes))': FunctionFragment; + 'cancelOutboundQueuedTransfer(uint64)': FunctionFragment; 'chainId()': FunctionFragment; 'completeInboundQueuedTransfer(bytes32)': FunctionFragment; 'completeOutboundQueuedTransfer(uint64)': FunctionFragment; @@ -150,7 +154,7 @@ export interface NttManagerInterface extends utils.Interface { 'tokenDecimals()': FunctionFragment; 'transceiverAttestedToMessage(bytes32,uint8)': FunctionFragment; 'transfer(uint256,uint16,bytes32)': FunctionFragment; - 'transfer(uint256,uint16,bytes32,bool,bytes)': FunctionFragment; + 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)': FunctionFragment; 'transferOwnership(address)': FunctionFragment; 'transferPauserCapability(address)': FunctionFragment; 'unpause()': FunctionFragment; @@ -161,6 +165,7 @@ export interface NttManagerInterface extends utils.Interface { nameOrSignatureOrTopic: | 'NTT_MANAGER_VERSION' | 'attestationReceived' + | 'cancelOutboundQueuedTransfer' | 'chainId' | 'completeInboundQueuedTransfer' | 'completeOutboundQueuedTransfer' @@ -199,7 +204,7 @@ export interface NttManagerInterface extends utils.Interface { | 'tokenDecimals' | 'transceiverAttestedToMessage' | 'transfer(uint256,uint16,bytes32)' - | 'transfer(uint256,uint16,bytes32,bool,bytes)' + | 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)' | 'transferOwnership' | 'transferPauserCapability' | 'unpause' @@ -218,6 +223,10 @@ export interface NttManagerInterface extends utils.Interface { TransceiverStructs.NttManagerMessageStruct, ], ): string; + encodeFunctionData( + functionFragment: 'cancelOutboundQueuedTransfer', + values: [BigNumberish], + ): string; encodeFunctionData(functionFragment: 'chainId', values?: undefined): string; encodeFunctionData( functionFragment: 'completeInboundQueuedTransfer', @@ -348,8 +357,15 @@ export interface NttManagerInterface extends utils.Interface { values: [BigNumberish, BigNumberish, BytesLike], ): string; encodeFunctionData( - functionFragment: 'transfer(uint256,uint16,bytes32,bool,bytes)', - values: [BigNumberish, BigNumberish, BytesLike, boolean, BytesLike], + functionFragment: 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)', + values: [ + BigNumberish, + BigNumberish, + BytesLike, + BytesLike, + boolean, + BytesLike, + ], ): string; encodeFunctionData( functionFragment: 'transferOwnership', @@ -370,6 +386,10 @@ export interface NttManagerInterface extends utils.Interface { functionFragment: 'attestationReceived', data: BytesLike, ): Result; + decodeFunctionResult( + functionFragment: 'cancelOutboundQueuedTransfer', + data: BytesLike, + ): Result; decodeFunctionResult(functionFragment: 'chainId', data: BytesLike): Result; decodeFunctionResult( functionFragment: 'completeInboundQueuedTransfer', @@ -484,7 +504,7 @@ export interface NttManagerInterface extends utils.Interface { data: BytesLike, ): Result; decodeFunctionResult( - functionFragment: 'transfer(uint256,uint16,bytes32,bool,bytes)', + functionFragment: 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)', data: BytesLike, ): Result; decodeFunctionResult( @@ -506,6 +526,7 @@ export interface NttManagerInterface extends utils.Interface { 'MessageAlreadyExecuted(bytes32,bytes32)': EventFragment; 'MessageAttestedTo(bytes32,address,uint8)': EventFragment; 'NotPaused(bool)': EventFragment; + 'OutboundTransferCancelled(uint256,address,uint256)': EventFragment; 'OutboundTransferQueued(uint64)': EventFragment; 'OutboundTransferRateLimited(address,uint64,uint256,uint256)': EventFragment; 'OwnershipTransferred(address,address)': EventFragment; @@ -516,7 +537,7 @@ export interface NttManagerInterface extends utils.Interface { 'TransceiverAdded(address,uint256,uint8)': EventFragment; 'TransceiverRemoved(address,uint8)': EventFragment; 'TransferRedeemed(bytes32)': EventFragment; - 'TransferSent(bytes32,uint256,uint256,uint16,uint64)': EventFragment; + 'TransferSent(bytes32,bytes32,uint256,uint256,uint16,uint64)': EventFragment; 'Upgraded(address)': EventFragment; }; @@ -527,6 +548,7 @@ export interface NttManagerInterface extends utils.Interface { getEvent(nameOrSignatureOrTopic: 'MessageAlreadyExecuted'): EventFragment; getEvent(nameOrSignatureOrTopic: 'MessageAttestedTo'): EventFragment; getEvent(nameOrSignatureOrTopic: 'NotPaused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OutboundTransferCancelled'): EventFragment; getEvent(nameOrSignatureOrTopic: 'OutboundTransferQueued'): EventFragment; getEvent( nameOrSignatureOrTopic: 'OutboundTransferRateLimited', @@ -614,6 +636,19 @@ export type NotPausedEvent = TypedEvent<[boolean], NotPausedEventObject>; export type NotPausedEventFilter = TypedEventFilter; +export interface OutboundTransferCancelledEventObject { + sequence: BigNumber; + recipient: string; + amount: BigNumber; +} +export type OutboundTransferCancelledEvent = TypedEvent< + [BigNumber, string, BigNumber], + OutboundTransferCancelledEventObject +>; + +export type OutboundTransferCancelledEventFilter = + TypedEventFilter; + export interface OutboundTransferQueuedEventObject { queueSequence: BigNumber; } @@ -734,13 +769,14 @@ export type TransferRedeemedEventFilter = export interface TransferSentEventObject { recipient: string; + refundAddress: string; amount: BigNumber; fee: BigNumber; recipientChain: number; msgSequence: BigNumber; } export type TransferSentEvent = TypedEvent< - [string, BigNumber, BigNumber, number, BigNumber], + [string, string, BigNumber, BigNumber, number, BigNumber], TransferSentEventObject >; @@ -789,6 +825,11 @@ export interface NttManager extends BaseContract { overrides?: Overrides & { from?: string }, ): Promise; + cancelOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + chainId(overrides?: CallOverrides): Promise<[number]>; completeInboundQueuedTransfer( @@ -945,10 +986,11 @@ export interface NttManager extends BaseContract { overrides?: PayableOverrides & { from?: string }, ): Promise; - 'transfer(uint256,uint16,bytes32,bool,bytes)'( + 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)'( amount: BigNumberish, recipientChain: BigNumberish, recipient: BytesLike, + refundAddress: BytesLike, shouldQueue: boolean, transceiverInstructions: BytesLike, overrides?: PayableOverrides & { from?: string }, @@ -983,6 +1025,11 @@ export interface NttManager extends BaseContract { overrides?: Overrides & { from?: string }, ): Promise; + cancelOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + chainId(overrides?: CallOverrides): Promise; completeInboundQueuedTransfer( @@ -1137,10 +1184,11 @@ export interface NttManager extends BaseContract { overrides?: PayableOverrides & { from?: string }, ): Promise; - 'transfer(uint256,uint16,bytes32,bool,bytes)'( + 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)'( amount: BigNumberish, recipientChain: BigNumberish, recipient: BytesLike, + refundAddress: BytesLike, shouldQueue: boolean, transceiverInstructions: BytesLike, overrides?: PayableOverrides & { from?: string }, @@ -1175,6 +1223,11 @@ export interface NttManager extends BaseContract { overrides?: CallOverrides, ): Promise; + cancelOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: CallOverrides, + ): Promise; + chainId(overrides?: CallOverrides): Promise; completeInboundQueuedTransfer( @@ -1323,10 +1376,11 @@ export interface NttManager extends BaseContract { overrides?: CallOverrides, ): Promise; - 'transfer(uint256,uint16,bytes32,bool,bytes)'( + 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)'( amount: BigNumberish, recipientChain: BigNumberish, recipient: BytesLike, + refundAddress: BytesLike, shouldQueue: boolean, transceiverInstructions: BytesLike, overrides?: CallOverrides, @@ -1396,6 +1450,17 @@ export interface NttManager extends BaseContract { 'NotPaused(bool)'(notPaused?: null): NotPausedEventFilter; NotPaused(notPaused?: null): NotPausedEventFilter; + 'OutboundTransferCancelled(uint256,address,uint256)'( + sequence?: null, + recipient?: null, + amount?: null, + ): OutboundTransferCancelledEventFilter; + OutboundTransferCancelled( + sequence?: null, + recipient?: null, + amount?: null, + ): OutboundTransferCancelledEventFilter; + 'OutboundTransferQueued(uint64)'( queueSequence?: null, ): OutboundTransferQueuedEventFilter; @@ -1486,8 +1551,9 @@ export interface NttManager extends BaseContract { ): TransferRedeemedEventFilter; TransferRedeemed(digest?: BytesLike | null): TransferRedeemedEventFilter; - 'TransferSent(bytes32,uint256,uint256,uint16,uint64)'( + 'TransferSent(bytes32,bytes32,uint256,uint256,uint16,uint64)'( recipient?: null, + refundAddress?: null, amount?: null, fee?: null, recipientChain?: null, @@ -1495,6 +1561,7 @@ export interface NttManager extends BaseContract { ): TransferSentEventFilter; TransferSent( recipient?: null, + refundAddress?: null, amount?: null, fee?: null, recipientChain?: null, @@ -1515,6 +1582,11 @@ export interface NttManager extends BaseContract { overrides?: Overrides & { from?: string }, ): Promise; + cancelOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + chainId(overrides?: CallOverrides): Promise; completeInboundQueuedTransfer( @@ -1661,10 +1733,11 @@ export interface NttManager extends BaseContract { overrides?: PayableOverrides & { from?: string }, ): Promise; - 'transfer(uint256,uint16,bytes32,bool,bytes)'( + 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)'( amount: BigNumberish, recipientChain: BigNumberish, recipient: BytesLike, + refundAddress: BytesLike, shouldQueue: boolean, transceiverInstructions: BytesLike, overrides?: PayableOverrides & { from?: string }, @@ -1700,6 +1773,11 @@ export interface NttManager extends BaseContract { overrides?: Overrides & { from?: string }, ): Promise; + cancelOutboundQueuedTransfer( + messageSequence: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + chainId(overrides?: CallOverrides): Promise; completeInboundQueuedTransfer( @@ -1860,10 +1938,11 @@ export interface NttManager extends BaseContract { overrides?: PayableOverrides & { from?: string }, ): Promise; - 'transfer(uint256,uint16,bytes32,bool,bytes)'( + 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)'( amount: BigNumberish, recipientChain: BigNumberish, recipient: BytesLike, + refundAddress: BytesLike, shouldQueue: boolean, transceiverInstructions: BytesLike, overrides?: PayableOverrides & { from?: string }, diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager__factory.ts index 3c3cf5f9a..e92b4433a 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager__factory.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/NttManager__factory.ts @@ -71,6 +71,22 @@ const _abi = [ name: 'CallerNotTransceiver', type: 'error', }, + { + inputs: [ + { + internalType: 'address', + name: 'canceller', + type: 'address', + }, + { + internalType: 'address', + name: 'sender', + type: 'address', + }, + ], + name: 'CancellerNotSender', + type: 'error', + }, { inputs: [ { @@ -220,6 +236,11 @@ const _abi = [ name: 'InvalidRecipient', type: 'error', }, + { + inputs: [], + name: 'InvalidRefundAddress', + type: 'error', + }, { inputs: [ { @@ -633,6 +654,31 @@ const _abi = [ name: 'NotPaused', type: 'event', }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint256', + name: 'sequence', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address', + name: 'recipient', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'OutboundTransferCancelled', + type: 'event', + }, { anonymous: false, inputs: [ @@ -850,6 +896,12 @@ const _abi = [ name: 'recipient', type: 'bytes32', }, + { + indexed: false, + internalType: 'bytes32', + name: 'refundAddress', + type: 'bytes32', + }, { indexed: false, internalType: 'uint256', @@ -944,6 +996,19 @@ const _abi = [ stateMutability: 'nonpayable', type: 'function', }, + { + inputs: [ + { + internalType: 'uint64', + name: 'messageSequence', + type: 'uint64', + }, + ], + name: 'cancelOutboundQueuedTransfer', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, { inputs: [], name: 'chainId', @@ -1206,6 +1271,11 @@ const _abi = [ name: 'recipient', type: 'bytes32', }, + { + internalType: 'bytes32', + name: 'refundAddress', + type: 'bytes32', + }, { internalType: 'TrimmedAmount', name: 'amount', @@ -1676,6 +1746,11 @@ const _abi = [ name: 'recipient', type: 'bytes32', }, + { + internalType: 'bytes32', + name: 'refundAddress', + type: 'bytes32', + }, { internalType: 'bool', name: 'shouldQueue', @@ -1747,7 +1822,7 @@ const _abi = [ ] as const; const _bytecode = - '0x6101606040523480156200001257600080fd5b5060405162006a4838038062006a488339810160408190526200003591620005a6565b84848484846001600160401b03821615801562000050575080155b806200006d57506001600160401b038216158015906200006d5750805b156200008c5760405163e543ef0560e01b815260040160405180910390fd5b506001600160401b0316608052620000a36200010d565b620000ad62000279565b3060a0526001600160a01b03831660c052816001811115620000d357620000d362000640565b610100816001811115620000eb57620000eb62000640565b90525061ffff16610120525050466101405250503360e05250620006e0915050565b6000620001196200032d565b905060006200012762000363565b82548154919250610100900460ff1690811462000148576200014862000656565b60005b818110156200019d57620001888382815481106200016d576200016d6200066c565b6000918252602090912001546001600160a01b031662000392565b80620001948162000698565b9150506200014b565b5060005b8181101562000259576000620001b9826001620006b4565b90505b828110156200024357838181548110620001da57620001da6200066c565b60009182526020909120015484546001600160a01b03909116908590849081106200020957620002096200066c565b6000918252602090912001546001600160a01b0316036200022e576200022e62000656565b806200023a8162000698565b915050620001bc565b5080620002508162000698565b915050620001a1565b508254604060ff909116111562000274576200027462000656565b505050565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00805468010000000000000000900460ff1615620002ca5760405163f92ee8a960e01b815260040160405180910390fd5b80546001600160401b03908116146200032a5780546001600160401b0319166001600160401b0390811782556040519081527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b50565b6000806200035d60017f8561949d1c6242cee5c5a5aeb6b9c190ee611d7742fcec65d9e5b1341ea04d8a620006ca565b92915050565b6000806200035d60017e758a264b9bdbe3295fe36bd6ff7abaa122f48bf70e90af04a1b8a32d21e4e2620006ca565b60006200039e62000530565b90506000620003ac62000560565b90506000620003ba6200032d565b90506000620003c862000363565b6001600160a01b038616600090815260208681526040918290208251606081018452905460ff80821615158084526101008304821615159484019490945262010000909104169281019290925291925090806200043857508060200151158015620004385750604081015160ff16155b62000447576200044762000656565b604081015184546020830151600160ff9093169290921b166001600160401b03161515906000805b8654610100900460ff16811015620004da57896001600160a01b0316868281548110620004a057620004a06200066c565b6000918252602090912001546001600160a01b031603620004c55760019150620004da565b80620004d18162000698565b9150506200046f565b5081151583151514620004f157620004f162000656565b8115158115151462000507576200050762000656565b8554604085015160ff91821691161062000525576200052562000656565b505050505050505050565b6000806200035d60017f49bca747e973430e858f2f5de357b8dba36ea6d375b81bdb5d53dfaabf0b3a80620006ca565b6000806200035d60017ffd6568c039679b3b7cc93c26c41d9379b7b1bec1677120493b467688302cb120620006ca565b80518015158114620005a157600080fd5b919050565b600080600080600060a08688031215620005bf57600080fd5b85516001600160a01b0381168114620005d757600080fd5b602087015190955060028110620005ed57600080fd5b604087015190945061ffff811681146200060657600080fd5b60608701519093506001600160401b03811681146200062457600080fd5b9150620006346080870162000590565b90509295509295909350565b634e487b7160e01b600052602160045260246000fd5b634e487b7160e01b600052600160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b600060018201620006ad57620006ad62000682565b5060010190565b808201808211156200035d576200035d62000682565b818103818111156200035d576200035d62000682565b60805160a05160c05160e051610100516101205161014051616234620008146000396000611a8701526000818161067101528181611b4c01528181611b9c0152614d680152600081816103e801528181610d4001528181612749015281816127bb0152818161287901528181612cad0152614cb6015260008181613f150152613f5101526000818161087d01528181610c9f0152818161278b0152818161281601528181612c1301528181612c4701528181612c7601528181612cf801528181612d6301528181612f2e0152614c140152600061263d0152600081816104af015281816110790152818161164801528181611e7401528181611ed5015281816137470152818161386d015281816138d301528181613bad015281816142660152818161446801526144b801526162346000f3fe6080604052600436106102725760003560e01c80638da5cb5b1161014f578063b187bd26116100c1578063e5a986031161007a578063e5a9860314610801578063e75235b814610821578063f2fde38b14610836578063f5cfec1814610856578063fc0c546a1461086b578063fd96063c1461089f57600080fd5b8063b187bd261461070e578063b4d591bb14610723578063c0b07bde14610745578063c128d17014610783578063d788c147146107c1578063da4856a1146107e157600080fd5b806397c351461161011357806397c351461461064c5780639a8a05921461065f5780639d782454146106a65780639f86029c146106c65780639fd0506d146106e6578063a2713356146106fb57600080fd5b80638da5cb5b146105a95780638e3ba8c9146105d65780638fd3ab80146105f65780639057412d1461060b578063961b94d01461063957600080fd5b80633b97e856116101e85780637c918634116101ac5780637c918634146104d15780638129fc1c146104f15780638413bcba146105065780638456cb591461052657806386e11ffa1461053b57806389c619dd1461058957600080fd5b80633b97e856146104375780633f4ba83a1461045e5780634b4fd03b14610473578063689f90c31461048857806374aa7bfc1461049d57600080fd5b8063190171751161023a578063190171751461033c5780631f97c9a81461035c578063203e4a9b1461038957806323d75e31146103a9578063295a5212146103d6578063396c16b71461041757600080fd5b80630271725014610277578063036de8af146102aa5780630677df54146102cc5780630900f010146102fc578063186ce6121461031c575b600080fd5b34801561028357600080fd5b50610297610292366004615456565b6108fc565b6040519081526020015b60405180910390f35b3480156102b657600080fd5b506102ca6102c5366004615488565b610939565b005b3480156102d857600080fd5b506102ec6102e73660046154a5565b6109a5565b60405190151581526020016102a1565b34801561030857600080fd5b506102ca610317366004615488565b6109da565b34801561032857600080fd5b506102ca6103373660046154be565b6109ee565b34801561034857600080fd5b506102ca6103573660046154a5565b610a1b565b34801561036857600080fd5b5061037c610377366004615503565b610a46565b6040516102a19190615570565b34801561039557600080fd5b506102ca6103a4366004615488565b610b95565b3480156103b557600080fd5b506103be610c2f565b6040516001600160401b0390911681526020016102a1565b3480156103e257600080fd5b5061040a7f000000000000000000000000000000000000000000000000000000000000000081565b6040516102a191906155f1565b34801561042357600080fd5b506102ec6104323660046154a5565b610c48565b34801561044357600080fd5b5061044c610c66565b60405160ff90911681526020016102a1565b34801561046a57600080fd5b506102ca610d27565b34801561047f57600080fd5b5061044c610d3c565b34801561049457600080fd5b506102ec610d75565b3480156104a957600080fd5b506103be7f000000000000000000000000000000000000000000000000000000000000000081565b3480156104dd57600080fd5b506102ca6104ec366004615628565b610d88565b3480156104fd57600080fd5b506102ca610f04565b34801561051257600080fd5b506102ca6105213660046154a5565b611006565b34801561053257600080fd5b506102ca611151565b34801561054757600080fd5b50610550611164565b6040805182516001600160481b03908116825260208085015190911690820152918101516001600160401b0316908201526060016102a1565b34801561059557600080fd5b5061044c6105a43660046154a5565b6111c8565b3480156105b557600080fd5b506105be6111e1565b6040516001600160a01b0390911681526020016102a1565b3480156105e257600080fd5b506102ec6105f1366004615670565b61120f565b34801561060257600080fd5b506102ca611249565b34801561061757600080fd5b5061062b610626366004615780565b61134b565b6040516102a19291906157cf565b6103be610647366004615817565b61144e565b6103be61065a366004615503565b6114c5565b34801561066b57600080fd5b506106937f000000000000000000000000000000000000000000000000000000000000000081565b60405161ffff90911681526020016102a1565b3480156106b257600080fd5b506102ca6106c136600461584f565b611766565b3480156106d257600080fd5b506102ca6106e1366004615488565b611803565b3480156106f257600080fd5b506105be61189c565b6103be610709366004615913565b6118b5565b34801561071a57600080fd5b506102ec611914565b34801561072f57600080fd5b50610738611929565b6040516102a19190615988565b34801561075157600080fd5b50610776604051806040016040528060058152602001640302e312e360dc1b81525081565b6040516102a191906159d5565b34801561078f57600080fd5b506107a361079e366004615456565b611991565b604080518251815260209283015160ff1692810192909252016102a1565b3480156107cd57600080fd5b506105506107dc366004615456565b6119e1565b3480156107ed57600080fd5b506102ca6107fc36600461584f565b611a5c565b34801561080d57600080fd5b506102ca61081c3660046159e8565b611c6d565b34801561082d57600080fd5b5061044c611cf8565b34801561084257600080fd5b506102ca610851366004615488565b611d02565b34801561086257600080fd5b50610297611dc0565b34801561087757600080fd5b506105be7f000000000000000000000000000000000000000000000000000000000000000081565b3480156108ab57600080fd5b506108bf6108ba3660046154a5565b611df6565b6040805182516001600160481b031681526020808401516001600160401b031690820152918101516001600160a01b0316908201526060016102a1565b60008061091061090b846119e1565b611e70565b9050600061091c610c66565b90506109316001600160481b03831682611f75565b949350505050565b6109496109446111e1565b611f9f565b6000610953611fe8565b80546001600160a01b038481166001600160a01b031983168117845560405193945091169182907f51c4874e0f23f262e04a38c51751336dde72126d67f53eb672aaff02996b3ef690600090a3505050565b6000806109b0611cf8565b90508060ff166109bf846111c8565b60ff16101580156109d3575060008160ff16115b9392505050565b6109e2612016565b6109eb81612048565b50565b6109f6612016565b6000610a00610c66565b9050610a16610a10848380612156565b836121a3565b505050565b610a23612016565b6000610a2d610c66565b9050610a42610a3d838380612156565b6121c8565b5050565b6040805160c0810182526000808252602082018190529181018290526060808201839052608082019290925260a0810191909152610a826121d9565b6001600160401b0383811660009081526020928352604090819020815160c0810183528154815260018201546001600160481b03811695820195909552600160481b850490931691830191909152600160881b90920461ffff16606082015260028201546001600160a01b0316608082015260038201805491929160a084019190610b0c90615a05565b80601f0160208091040260200160405190810160405280929190818152602001828054610b3890615a05565b8015610b855780601f10610b5a57610100808354040283529160200191610b85565b820191906000526020600020905b815481529060010190602001808311610b6857829003601f168201915b5050505050815250509050919050565b610b9d612016565b610ba681612207565b506000610bb16124b9565b805490915060ff16600003610bcc57805460ff191660011781555b7ff05962b5774c658e85ed80c91a75af9d66d2af2253dda480f90bce78aff5eda582610bf66124e7565b548354604080516001600160a01b03909416845261010090920460ff908116602085015216908201526060015b60405180910390a15050565b6000610c39612515565b546001600160401b0316919050565b6000610c52612543565b600092835260205250604090205460ff1690565b60408051600481526024810182526020810180516001600160e01b031663313ce56760e01b179052905160009182916001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001691610cc991615a3f565b600060405180830381855afa9150503d8060008114610d04576040519150601f19603f3d011682016040523d82523d6000602084013e610d09565b606091505b5091505080806020019051810190610d219190615a5b565b91505090565b610d326109446111e1565b610d3a612571565b565b60007f00000000000000000000000000000000000000000000000000000000000000006001811115610d7057610d706155db565b905090565b6000610d7f6125d7565b5460ff16919050565b610d90612016565b8361ffff16600003610db55760405163100b0f2760e11b815260040160405180910390fd5b82610dd35760405163f839a0cb60e01b815260040160405180910390fd5b8160ff16600003610df75760405163ade64f0b60e01b815260040160405180910390fd5b6000610e01612605565b61ffff8616600090815260209182526040908190208151808301909252805482526001015460ff1691810191909152905083610e3b612605565b61ffff87166000908152602091909152604090205582610e59612605565b61ffff8716600090815260209190915260408120600101805460ff191660ff9390931692909217909155610e8b610c66565b9050610ea1610e9b848380612156565b876121a3565b81516020808401516040805193845260ff918216928401929092529082018790528516606082015261ffff8716907f1456404e7f41f35c3daac941bb50bad417a66275c3040061b4287d787719599d9060800160405180910390a2505050505050565b610f0c612633565b6000805160206161df8339815191528054600160401b810460ff1615906001600160401b0316600081158015610f3f5750825b90506000826001600160401b03166001148015610f5b5750303b155b905081158015610f69575080155b15610f875760405163f92ee8a960e01b815260040160405180910390fd5b845467ffffffffffffffff191660011785558315610fb157845460ff60401b1916600160401b1785555b610fb961267c565b8315610fff57845460ff60401b19168555604051600181527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b5050505050565b61100e612694565b611016611914565b15611034576040516309e3d0f360e11b815260040160405180910390fd5b600061103f82611df6565b905080602001516001600160401b031660000361107757604051630301bcaf60e61b8152600481018390526024015b60405180910390fd5b7f00000000000000000000000000000000000000000000000000000000000000006001600160401b031681602001516001600160401b0316426110ba9190615a8e565b10156110f15760208101516040516301cb739d60e71b8152600481018490526001600160401b03909116602482015260440161106e565b6110f96126cc565b600083815260209190915260409081902080546001600160881b031916815560010180546001600160a01b031916905581015181516111399184916126fa565b506109eb60016000805160206161bf83398151915255565b61115c6109446111e1565b610d3a6128dc565b604080516060810182526000808252602082018190529181019190915261118961293d565b6040805160608101825291546001600160481b038082168452600160481b8204166020840152600160901b90046001600160401b031690820152919050565b60006111db6111d68361296b565b6129a7565b92915050565b7f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300546001600160a01b031690565b600080600160ff84161b611221612543565b600086815260209190915260409020546101009004166001600160401b031611905092915050565b611251612633565b6112596129da565b611264906001615aa1565b6000805160206161df8339815191528054600160401b900460ff1680611297575080546001600160401b03808416911610155b156112b55760405163f92ee8a960e01b815260040160405180910390fd5b805468ffffffffffffffffff19166001600160401b03831617600160401b1781556112de6129f0565b5460ff166112ff57604051632866815360e11b815260040160405180910390fd5b611307612684565b805460ff60401b191681556040516001600160401b03831681527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d290602001610c23565b6060600080611358612a1e565b8054806020026020016040519081016040528092919081815260200182805480156113ac57602002820191906000526020600020905b81546001600160a01b0316815260019091019060200180831161138e575b50505050509050600073__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$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$93083e246e55d56d98f3df2872cd16bfd0$__638b4979b86040518060600160405280866001600160401b031660001b8152602001612fb78e6001600160a01b031690565b8152604080516315cfa3cb60e11b815287516001600160481b031660048201526020888101516024830152918801516044820152606088015161ffff16606482015291019073__$93083e246e55d56d98f3df2872cd16bfd0$__90632b9f479690608401600060405180830381865af4158015613038573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526130609190810190615dcd565b8152506040518263ffffffff1660e01b815260040161307f9190615e2a565b600060405180830381865af415801561309c573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526130c49190810190615dcd565b90506130f08c6130d2612605565b61ffff8f166000908152602091909152604090205487898b866146a7565b8c8c7f9716fe52fe4e02cf924ae28f19f5748ef59877c6496041b986fbad3dae6a8ecf8d61312f61311f610c66565b6001600160481b03861690611f75565b604080519283526020830191909152810188905261ffff831660608201526001600160401b038716608082015260a00160405180910390a1509d9e9d5050505050505050505050505050565b6000806111db60017f49bca747e973430e858f2f5de357b8dba36ea6d375b81bdb5d53dfaabf0b3a80615a8e565b806131b2612605565b61ffff84166000908152602091909152604090205414610a4257604051635788c0fd60e11b815261ffff831660048201526024810182905260440161106e565b60008073__$93083e246e55d56d98f3df2872cd16bfd0$__63b3f07bbd85856040518363ffffffff1660e01b815260040161322e929190615e3d565b602060405180830381865af415801561324b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061326f9190615da1565b905061329c8161327d61317b565b336000908152602091909152604090205462010000900460ff1661120f565b156132bd57604051631089c4a160e11b81526004810182905260240161106e565b6109d381336147e4565b60006132d161317b565b905060006132dd613d86565b905060006132e9612a1e565b90506001600160a01b03841661331257604051632f44bd7760e01b815260040160405180910390fd5b6001600160a01b03841660009081526020849052604090205460ff1661335657604051630d583f4760e41b81526001600160a01b038516600482015260240161106e565b6001600160a01b038416600090815260208490526040902054610100900460ff1661339f576040516307d86e9160e21b81526001600160a01b038516600482015260240161106e565b6001600160a01b0384166000908152602084905260409020805461ff00191690556133c86124e7565b8054610100900460ff169060016133de83615e5a565b82546101009290920a60ff8181021990931691831602179091556001600160a01b03861660009081526020869052604090205484546001600160401b036001620100009093049093169190911b1981168216925016811061344157613441615cf0565b825467ffffffffffffffff19166001600160401b0382161783558154600090815b8181101561356757876001600160a01b031685828154811061348657613486615cab565b6000918252602090912001546001600160a01b03160361355557846134ac600184615a8e565b815481106134bc576134bc615cab565b9060005260206000200160009054906101000a90046001600160a01b03168582815481106134ec576134ec615cab565b9060005260206000200160006101000a8154816001600160a01b0302191690836001600160a01b031602179055508480548061352a5761352a615e77565b600082815260209020810160001990810180546001600160a01b031916905501905560019250613567565b8061355f81615cc1565b915050613462565b508161357557613575615cf0565b61357d613db4565b61358687614885565b50505050505050565b6000806111db60017f64bacf405c5d7f563d3ba5252584a52c37e4fee380fd825b10666c27b8258023615a8e565b6000806111db60017fefb21dcaedea63b55c44882f329622e13a8d0f5b947b3a372826208a9003da16615a8e565b4681146109eb576040516377d879fb60e01b81526004810182905246602482015260440161106e565b600080600073__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$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'; + '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$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$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$93083e246e55d56d98f3df2872cd16bfd0$__638b4979b86040518060600160405280866001600160401b031660001b81526020016132b68e6001600160a01b031690565b8152604080516315cfa3cb60e11b815287516001600160481b031660048201526020888101516024830152918801516044820152606088015161ffff16606482015291019073__$93083e246e55d56d98f3df2872cd16bfd0$__90632b9f479690608401600060405180830381865af4158015613337573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f1916820160405261335f9190810190616115565b8152506040518263ffffffff1660e01b815260040161337e9190616172565b600060405180830381865af415801561339b573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526133c39190810190616115565b90508c6133f1818d6133d361288f565b61ffff851660009081526020919091526040902054898b8d886149bf565b8e7fe54e51e42099622516fa3b48e9733581c9dbdcb771cafb093f745a0532a359828e8e613430613420610c9e565b6001600160481b03861690612209565b604080519384526020840192909252908201526060810188905261ffff841660808201526001600160401b03871660a082015260c00160405180910390a150929f9e505050505050505050505050505050565b60008061121460017f49bca747e973430e858f2f5de357b8dba36ea6d375b81bdb5d53dfaabf0b3a80615dc9565b806134ba61288f565b61ffff84166000908152602091909152604090205414610a6d57604051635788c0fd60e11b815261ffff83166004820152602481018290526044016110a6565b60008073__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$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$93083e246e55d56d98f3df2872cd16bfd0$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'; type NttManagerConstructorParams = | [linkLibraryAddresses: NttManagerLibraryAddresses, signer?: Signer] diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver.ts index c0ba9c8e3..631d0be01 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver.ts @@ -93,7 +93,7 @@ export interface WormholeTransceiverInterface extends utils.Interface { 'quoteDeliveryPrice(uint16,(uint8,bytes))': FunctionFragment; 'receiveMessage(bytes)': FunctionFragment; 'receiveWormholeMessages(bytes,bytes[],bytes32,uint16,bytes32)': FunctionFragment; - 'sendMessage(uint16,(uint8,bytes),bytes,bytes32)': FunctionFragment; + 'sendMessage(uint16,(uint8,bytes),bytes,bytes32,bytes32)': FunctionFragment; 'setIsSpecialRelayingEnabled(uint16,bool)': FunctionFragment; 'setIsWormholeEvmChain(uint16,bool)': FunctionFragment; 'setIsWormholeRelayingEnabled(uint16,bool)': FunctionFragment; @@ -230,6 +230,7 @@ export interface WormholeTransceiverInterface extends utils.Interface { TransceiverStructs.TransceiverInstructionStruct, BytesLike, BytesLike, + BytesLike, ], ): string; encodeFunctionData( @@ -395,7 +396,7 @@ export interface WormholeTransceiverInterface extends utils.Interface { 'PauserTransferred(address,address)': EventFragment; 'ReceivedMessage(bytes32,uint16,bytes32,uint64)': EventFragment; 'ReceivedRelayedMessage(bytes32,uint16,bytes32)': EventFragment; - 'RelayingInfo(uint8,uint256)': EventFragment; + 'RelayingInfo(uint8,bytes32,uint256)': EventFragment; 'SendTransceiverMessage(uint16,(bytes32,bytes32,bytes,bytes))': EventFragment; 'SetIsSpecialRelayingEnabled(uint16,bool)': EventFragment; 'SetIsWormholeEvmChain(uint16,bool)': EventFragment; @@ -520,10 +521,11 @@ export type ReceivedRelayedMessageEventFilter = export interface RelayingInfoEventObject { relayingType: number; + refundAddress: string; deliveryPayment: BigNumber; } export type RelayingInfoEvent = TypedEvent< - [number, BigNumber], + [number, string, BigNumber], RelayingInfoEventObject >; @@ -716,6 +718,7 @@ export interface WormholeTransceiver extends BaseContract { instruction: TransceiverStructs.TransceiverInstructionStruct, nttManagerMessage: BytesLike, recipientNttManagerAddress: BytesLike, + refundAddress: BytesLike, overrides?: PayableOverrides & { from?: string }, ): Promise; @@ -857,6 +860,7 @@ export interface WormholeTransceiver extends BaseContract { instruction: TransceiverStructs.TransceiverInstructionStruct, nttManagerMessage: BytesLike, recipientNttManagerAddress: BytesLike, + refundAddress: BytesLike, overrides?: PayableOverrides & { from?: string }, ): Promise; @@ -994,6 +998,7 @@ export interface WormholeTransceiver extends BaseContract { instruction: TransceiverStructs.TransceiverInstructionStruct, nttManagerMessage: BytesLike, recipientNttManagerAddress: BytesLike, + refundAddress: BytesLike, overrides?: CallOverrides, ): Promise; @@ -1114,12 +1119,14 @@ export interface WormholeTransceiver extends BaseContract { emitterAddress?: null, ): ReceivedRelayedMessageEventFilter; - 'RelayingInfo(uint8,uint256)'( + 'RelayingInfo(uint8,bytes32,uint256)'( relayingType?: null, + refundAddress?: null, deliveryPayment?: null, ): RelayingInfoEventFilter; RelayingInfo( relayingType?: null, + refundAddress?: null, deliveryPayment?: null, ): RelayingInfoEventFilter; @@ -1259,6 +1266,7 @@ export interface WormholeTransceiver extends BaseContract { instruction: TransceiverStructs.TransceiverInstructionStruct, nttManagerMessage: BytesLike, recipientNttManagerAddress: BytesLike, + refundAddress: BytesLike, overrides?: PayableOverrides & { from?: string }, ): Promise; @@ -1412,6 +1420,7 @@ export interface WormholeTransceiver extends BaseContract { instruction: TransceiverStructs.TransceiverInstructionStruct, nttManagerMessage: BytesLike, recipientNttManagerAddress: BytesLike, + refundAddress: BytesLike, overrides?: PayableOverrides & { from?: string }, ): Promise; diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver__factory.ts index 6e4e00eaa..9fe97c4ea 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver__factory.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/abis/0.1.0/WormholeTransceiver__factory.ts @@ -520,6 +520,12 @@ const _abi = [ name: 'relayingType', type: 'uint8', }, + { + indexed: false, + internalType: 'bytes32', + name: 'refundAddress', + type: 'bytes32', + }, { indexed: false, internalType: 'uint256', @@ -1082,6 +1088,11 @@ const _abi = [ name: 'recipientNttManagerAddress', type: 'bytes32', }, + { + internalType: 'bytes32', + name: 'refundAddress', + type: 'bytes32', + }, ], name: 'sendMessage', outputs: [], @@ -1254,7 +1265,7 @@ const _abi = [ ] as const; const _bytecode = - '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__$93083e246e55d56d98f3df2872cd16bfd0$__906308a700d690610a62906309945ff160e41b908b90600401613461565b600060405180830381865af4158015610a7f573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610aa7919081019061354a565b81516020830151929450909250610ac191869190846116e6565b50505050505050565b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614610b155760405163c5aa615360e01b815233600482015260240161090e565b6107bb816117e9565b610b2661143e565b8161ffff16600003610b4b57604051630f7662c960e21b815260040160405180910390fd5b610b56811515611673565b610b5e611580565b61ffff841660008181526020928352604090819020939093558251908152831515918101919091527f528b18a533e892b5401d1fb63597275df9d2bb45b13e7695c3147cd07b9746c391016108bb565b6000610bb861185a565b5460ff16919050565b610bc961143e565b8161ffff16600003610bee57604051630f7662c960e21b815260040160405180910390fd5b80610c0c5760405163137063ef60e11b815260040160405180910390fd5b6000610c16611888565b61ffff84166000908152602091909152604090205490508015610c595760405163b55eeae960e01b815261ffff841660048201526024810182905260440161090e565b81610c62611888565b61ffff858116600081815260209384526040808220959095558451606081018652630c7e33e160e11b8152938401918252838501878152945163077650fb60e51b815284516001600160e01b0319166004820152915190921660248201529251604484015290917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169163b19a437e9173__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$__906308a700d690611368906309945ff160e41b908790600401613461565b600060405180830381865af4158015611385573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526113ad919081019061354a565b81516020830151929450909250610f3d91869190846116e6565b336113d0611131565b6001600160a01b0316141580156113f057506001600160a01b0381163314155b156107bb5760405163e2a08e5d60e01b815233600482015260240161090e565b6000806107e560017fbfa91572ce1e5fe8776a160d3b1f862e83f5ee2c080a7423b4761602a3ad124a6136f4565b33611447610f44565b6001600160a01b0316146114705760405163118cdaa760e01b815233600482015260240161090e565b565b61147a6118e4565b611483816124ff565b600061148d61193d565b805490915060ff16156114a2576114a2613707565b805460ff191660011781556040805163011fa75760e71b815290513091638fd3ab8091600480830192600092919082900301818387803b1580156114e557600080fd5b505af11580156114f9573d6000803e3d6000fd5b50505050306001600160a01b031663689f90c36040518163ffffffff1660e01b8152600401602060405180830381865afa15801561153b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061155f9190613728565b61156b5761156b61253f565b61157560006127c3565b805460ff1916905550565b6000806107e560017f16ee6ac6bf7a8d7c37112a9426e00852b215ac4f5c50536beb6c95f1ba47b4b06136f4565b6000816000036115c057506000919050565b816001036115d057506001919050565b60405163b998bad560e01b81526004810183905260240161090e565b6000806000806116058686600191810182015192910190565b909250905060fe8216156116315760405163f7a37b0760e01b815260ff8316600482015260240161090e565b60ff909116925090509250929050565b8082511461166f5781516040516355c5b3e360e11b815260048101919091526024810182905260440161090e565b5050565b6000811561168357506001919050565b506000919050565b919050565b6000806107e560017fd4cbc7742a1e11dcc33209ac33862ef146cfcb6d7f860df12df42105dfedb1ca6136f4565b60016116c86118b6565b60009283526020526040909120805460ff1916911515919091179055565b6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000168214611761576040516339dee99160e11b81527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031660048201526024810183905260440161090e565b60405163275e091560e21b81526001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690639d782454906117b190879087908690600401613745565b600060405180830381600087803b1580156117cb57600080fd5b505af11580156117df573d6000803e3d6000fd5b5050505050505050565b7f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c19930080546001600160a01b031981166001600160a01b03848116918217845560405192169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b6000806107e560017f5443fea4dc453d96b81ce55b62e11a4094cc4cbb8a360956a7253cfdb42506cc6136f4565b6000806107e560017f48c66ef0992b4bcc14f2551075db9459fc23bf706abb76034f1c66c1ba2846856136f4565b6000806107e560017f5e6aacb3f16e5b01c8b072a0ab4c38e919266014a45db863ee64a4580fb3e7e36136f4565b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016300361147057604051633c64f99360e21b815260040160405180910390fd5b6119356127de565b611470612871565b6000806107e560017f7487ca88d037ca20519908b1ee7556206bef53bce0226a348750cb9d4f688e4f6136f4565b6000806107e560017fe79d2e5e46f62be2ac831294e423b664f30320fb9ebaefd78a978cafe07c0f8d6136f4565b6000806107e560017f64bacf405c5d7f563d3ba5252584a52c37e4fee380fd825b10666c27b82580236136f4565b6000806119d783602001516107eb565b805190915015611a6b577f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316631a90a2196040518163ffffffff1660e01b8152600401602060405180830381865afa158015611a3f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611a63919061378f565b9150506107e5565b611a7484612b67565b15611a985760405163251268db60e21b815261ffff8516600482015260240161090e565b611aa184612b89565b15611b6c5760405163c23ee3c360e01b815261ffff851660048201526000602482018190527f00000000000000000000000000000000000000000000000000000000000000006044830152907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169063c23ee3c3906064016040805180830381865afa158015611b3d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b6191906137a8565b5092506107e5915050565b611b7584611172565b15611cdc5760006001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000166382745ce47f00000000000000000000000000000000000000000000000000000000000000006040516001600160e01b031960e084901b1681526001600160a01b03909116600482015261ffff8816602482015260006044820152606401602060405180830381865afa158015611c21573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611c45919061378f565b90507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316631a90a2196040518163ffffffff1660e01b8152600401602060405180830381865afa158015611ca5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611cc9919061378f565b611cd390826137cc565b925050506107e5565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316631a90a2196040518163ffffffff1660e01b8152600401602060405180830381865afa158015611a3f573d6000803e3d6000fd5b5092915050565b7f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00805460011901611d8557604051633ee5aeb560e01b815260040160405180910390fd5b60029055565b60408051600080825260208201928390526304616c8f60e21b909252819073__$93083e246e55d56d98f3df2872cd16bfd0$__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__$93083e246e55d56d98f3df2872cd16bfd0$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'; + '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__$93083e246e55d56d98f3df2872cd16bfd0$__906308a700d690610af4906309945ff160e41b908b90600401613495565b600060405180830381865af4158015610b11573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610b39919081019061357e565b81516020830151929450909250610b539186919084611d08565b50505050505050565b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614610ba75760405163c5aa615360e01b815233600482015260240161087e565b6107bb81611e0b565b610bb861143f565b8161ffff16600003610bdd57604051630f7662c960e21b815260040160405180910390fd5b610be8811515611c95565b610bf0611581565b61ffff841660008181526020928352604090819020939093558251908152831515918101919091527f528b18a533e892b5401d1fb63597275df9d2bb45b13e7695c3147cd07b9746c39101610952565b6000610c4a611e7c565b5460ff16919050565b610c5b61143f565b8161ffff16600003610c8057604051630f7662c960e21b815260040160405180910390fd5b80610c9e5760405163137063ef60e11b815260040160405180910390fd5b6000610ca8611eaa565b61ffff84166000908152602091909152604090205490508015610ceb5760405163b55eeae960e01b815261ffff841660048201526024810182905260440161087e565b81610cf4611eaa565b61ffff858116600081815260209384526040808220959095558451606081018652630c7e33e160e11b8152938401918252838501878152945163077650fb60e51b815284516001600160e01b0319166004820152915190921660248201529251604484015290917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169163b19a437e9173__$93083e246e55d56d98f3df2872cd16bfd0$__9063eeca1f6090606401600060405180830381865af4158015610dc8573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610df0919081019061363d565b7f00000000000000000000000000000000000000000000000000000000000000006040518463ffffffff1660e01b8152600401610e2f93929190613671565b6020604051808303816000875af1158015610e4e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e7291906136ba565b506040805161ffff86168152602081018590527fa559263ee060c7a2560843b3a064ff0376c9753ae3e2449b595a3b615d326466910160405180910390a150505050565b6000610ec0611ed8565b600092835260205250604090205460ff1690565b610edc611f06565b600080516020613bb68339815191528054600160401b810460ff1615906001600160401b0316600081158015610f0f5750825b90506000826001600160401b03166001148015610f2b5750303b155b905081158015610f39575080155b15610f575760405163f92ee8a960e01b815260040160405180910390fd5b845467ffffffffffffffff191660011785558315610f8157845460ff60401b1916600160401b1785555b610f89611f4f565b83156108bf57845460ff60401b19168555604051600181527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15050505050565b7f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300546001600160a01b031690565b61100b611f06565b600080516020613bb6833981519152546001600160401b031661102f9060016136eb565b600080516020613bb68339815191528054600160401b900460ff1680611062575080546001600160401b03808416911610155b156110805760405163f92ee8a960e01b815260040160405180910390fd5b805468ffffffffffffffffff19166001600160401b03831617600160401b1781556110a9611f5f565b5460ff166110ca57604051632866815360e11b815260040160405180910390fd5b805460ff60401b191681556040516001600160401b03831681527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d290602001610952565b6000611118611eaa565b61ffff909216600090815260209290925250604090205490565b61113a61143f565b8161ffff1660000361115f57604051630f7662c960e21b815260040160405180910390fd5b61116a811515611c95565b611172611f8d565b61ffff841660008181526020928352604090819020939093558251908152831515918101919091527f4add57d97a7bf5035340ea1212aeeb3d4d3887eb1faf3821a8224c3a6956a10c9101610952565b60006111cc611411565b546001600160a01b0316919050565b6000806111e6611fbb565b5460021492915050565b60006111fc8383611fe9565b9392505050565b60006107e56107cb611cb2565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611270573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611294919061370b565b905090565b6112a161143f565b6001600160a01b038116610ba757604051631e4fbdf760e01b81526000600482015260240161087e565b60006107e56107cb611f8d565b600060606112e583612363565b6040805160808101825260008082526020820152606091810182905281810191909152919350915060408051606080820183526000808352602083015291810191909152604051630453806b60e11b815273__$93083e246e55d56d98f3df2872cd16bfd0$__906308a700d690611369906309945ff160e41b908790600401613495565b600060405180830381865af4158015611386573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526113ae919081019061357e565b815160208301519294509092506108bf9186919084611d08565b336113d16111c2565b6001600160a01b0316141580156113f157506001600160a01b0381163314155b156107bb5760405163e2a08e5d60e01b815233600482015260240161087e565b6000806107e560017fbfa91572ce1e5fe8776a160d3b1f862e83f5ee2c080a7423b4761602a3ad124a613728565b33611448610fd5565b6001600160a01b0316146114715760405163118cdaa760e01b815233600482015260240161087e565b565b61147b611f06565b61148481612529565b600061148e611f5f565b805490915060ff16156114a3576114a361373b565b805460ff191660011781556040805163011fa75760e71b815290513091638fd3ab8091600480830192600092919082900301818387803b1580156114e657600080fd5b505af11580156114fa573d6000803e3d6000fd5b50505050306001600160a01b031663689f90c36040518163ffffffff1660e01b8152600401602060405180830381865afa15801561153c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611560919061375c565b61156c5761156c612569565b61157660006127ed565b805460ff1916905550565b6000806107e560017f16ee6ac6bf7a8d7c37112a9426e00852b215ac4f5c50536beb6c95f1ba47b4b0613728565b6000816000036115c157506000919050565b816001036115d157506001919050565b60405163b998bad560e01b81526004810183905260240161087e565b6000806000806116068686600191810182015192910190565b909250905060fe8216156116325760405163f7a37b0760e01b815260ff8316600482015260240161087e565b60ff909116925090509250929050565b808251146116705781516040516355c5b3e360e11b815260048101919091526024810182905260440161087e565b5050565b7f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f008054600119016116b857604051633ee5aeb560e01b815260040160405180910390fd5b60029055565b60408051600080825260208201928390526304616c8f60e21b909252819073__$93083e246e55d56d98f3df2872cd16bfd0$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$93083e246e55d56d98f3df2872cd16bfd0$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'; type WormholeTransceiverConstructorParams = | [linkLibraryAddresses: WormholeTransceiverLibraryAddresses, signer?: Signer] diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager.ts deleted file mode 100644 index 013f9e8d5..000000000 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager.ts +++ /dev/null @@ -1,1888 +0,0 @@ -/* Autogenerated file. Do not edit manually. */ -/* tslint:disable */ -/* eslint-disable */ -import type { - BaseContract, - BigNumber, - BigNumberish, - BytesLike, - CallOverrides, - ContractTransaction, - Overrides, - PayableOverrides, - PopulatedTransaction, - Signer, - utils, -} from 'ethers'; -import type { - FunctionFragment, - Result, - EventFragment, -} from '@ethersproject/abi'; -import type { Listener, Provider } from '@ethersproject/providers'; -import type { - TypedEventFilter, - TypedEvent, - TypedListener, - OnEvent, -} from '../common'; - -export declare namespace TransceiverStructs { - export type NttManagerMessageStruct = { - id: BytesLike; - sender: BytesLike; - payload: BytesLike; - }; - - export type NttManagerMessageStructOutput = [string, string, string] & { - id: string; - sender: string; - payload: string; - }; - - export type TransceiverInstructionStruct = { - index: BigNumberish; - payload: BytesLike; - }; - - export type TransceiverInstructionStructOutput = [number, string] & { - index: number; - payload: string; - }; -} - -export declare namespace IRateLimiter { - export type RateLimitParamsStruct = { - limit: BigNumberish; - currentCapacity: BigNumberish; - lastTxTimestamp: BigNumberish; - }; - - export type RateLimitParamsStructOutput = [ - BigNumber, - BigNumber, - BigNumber, - ] & { - limit: BigNumber; - currentCapacity: BigNumber; - lastTxTimestamp: BigNumber; - }; - - export type InboundQueuedTransferStruct = { - amount: BigNumberish; - txTimestamp: BigNumberish; - recipient: string; - }; - - export type InboundQueuedTransferStructOutput = [ - BigNumber, - BigNumber, - string, - ] & { amount: BigNumber; txTimestamp: BigNumber; recipient: string }; - - export type OutboundQueuedTransferStruct = { - recipient: BytesLike; - amount: BigNumberish; - txTimestamp: BigNumberish; - recipientChain: BigNumberish; - sender: string; - transceiverInstructions: BytesLike; - }; - - export type OutboundQueuedTransferStructOutput = [ - string, - BigNumber, - BigNumber, - number, - string, - string, - ] & { - recipient: string; - amount: BigNumber; - txTimestamp: BigNumber; - recipientChain: number; - sender: string; - transceiverInstructions: string; - }; -} - -export declare namespace INttManagerState { - export type NttManagerPeerStruct = { - peerAddress: BytesLike; - tokenDecimals: BigNumberish; - }; - - export type NttManagerPeerStructOutput = [string, number] & { - peerAddress: string; - tokenDecimals: number; - }; -} - -export interface NttManagerInterface extends utils.Interface { - functions: { - 'attestationReceived(uint16,bytes32,(bytes32,bytes32,bytes))': FunctionFragment; - 'chainId()': FunctionFragment; - 'completeInboundQueuedTransfer(bytes32)': FunctionFragment; - 'completeOutboundQueuedTransfer(uint64)': FunctionFragment; - 'executeMsg(uint16,bytes32,(bytes32,bytes32,bytes))': FunctionFragment; - 'getCurrentInboundCapacity(uint16)': FunctionFragment; - 'getCurrentOutboundCapacity()': FunctionFragment; - 'getInboundLimitParams(uint16)': FunctionFragment; - 'getInboundQueuedTransfer(bytes32)': FunctionFragment; - 'getMigratesImmutables()': FunctionFragment; - 'getMode()': FunctionFragment; - 'getOutboundLimitParams()': FunctionFragment; - 'getOutboundQueuedTransfer(uint64)': FunctionFragment; - 'getPeer(uint16)': FunctionFragment; - 'getThreshold()': FunctionFragment; - 'getTransceivers()': FunctionFragment; - 'initialize()': FunctionFragment; - 'isMessageApproved(bytes32)': FunctionFragment; - 'isMessageExecuted(bytes32)': FunctionFragment; - 'isPaused()': FunctionFragment; - 'messageAttestations(bytes32)': FunctionFragment; - 'migrate()': FunctionFragment; - 'mode()': FunctionFragment; - 'nextMessageSequence()': FunctionFragment; - 'owner()': FunctionFragment; - 'pause()': FunctionFragment; - 'pauser()': FunctionFragment; - 'quoteDeliveryPrice(uint16,(uint8,bytes)[],address[])': FunctionFragment; - 'rateLimitDuration()': FunctionFragment; - 'removeTransceiver(address)': FunctionFragment; - 'setInboundLimit(uint256,uint16)': FunctionFragment; - 'setOutboundLimit(uint256)': FunctionFragment; - 'setPeer(uint16,bytes32,uint8,uint256)': FunctionFragment; - 'setThreshold(uint8)': FunctionFragment; - 'setTransceiver(address)': FunctionFragment; - 'token()': FunctionFragment; - 'tokenDecimals()': FunctionFragment; - 'tokenDecimals_()': FunctionFragment; - 'transceiverAttestedToMessage(bytes32,uint8)': FunctionFragment; - 'transfer(uint256,uint16,bytes32)': FunctionFragment; - 'transfer(uint256,uint16,bytes32,bool,bytes)': FunctionFragment; - 'transferOwnership(address)': FunctionFragment; - 'transferPauserCapability(address)': FunctionFragment; - 'upgrade(address)': FunctionFragment; - }; - - getFunction( - nameOrSignatureOrTopic: - | 'attestationReceived' - | 'chainId' - | 'completeInboundQueuedTransfer' - | 'completeOutboundQueuedTransfer' - | 'executeMsg' - | 'getCurrentInboundCapacity' - | 'getCurrentOutboundCapacity' - | 'getInboundLimitParams' - | 'getInboundQueuedTransfer' - | 'getMigratesImmutables' - | 'getMode' - | 'getOutboundLimitParams' - | 'getOutboundQueuedTransfer' - | 'getPeer' - | 'getThreshold' - | 'getTransceivers' - | 'initialize' - | 'isMessageApproved' - | 'isMessageExecuted' - | 'isPaused' - | 'messageAttestations' - | 'migrate' - | 'mode' - | 'nextMessageSequence' - | 'owner' - | 'pause' - | 'pauser' - | 'quoteDeliveryPrice' - | 'rateLimitDuration' - | 'removeTransceiver' - | 'setInboundLimit' - | 'setOutboundLimit' - | 'setPeer' - | 'setThreshold' - | 'setTransceiver' - | 'token' - | 'tokenDecimals' - | 'tokenDecimals_' - | 'transceiverAttestedToMessage' - | 'transfer(uint256,uint16,bytes32)' - | 'transfer(uint256,uint16,bytes32,bool,bytes)' - | 'transferOwnership' - | 'transferPauserCapability' - | 'upgrade', - ): FunctionFragment; - - encodeFunctionData( - functionFragment: 'attestationReceived', - values: [ - BigNumberish, - BytesLike, - TransceiverStructs.NttManagerMessageStruct, - ], - ): string; - encodeFunctionData(functionFragment: 'chainId', values?: undefined): string; - encodeFunctionData( - functionFragment: 'completeInboundQueuedTransfer', - values: [BytesLike], - ): string; - encodeFunctionData( - functionFragment: 'completeOutboundQueuedTransfer', - values: [BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'executeMsg', - values: [ - BigNumberish, - BytesLike, - TransceiverStructs.NttManagerMessageStruct, - ], - ): 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?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'getTransceivers', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'initialize', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'isMessageApproved', - values: [BytesLike], - ): string; - encodeFunctionData( - functionFragment: 'isMessageExecuted', - values: [BytesLike], - ): string; - encodeFunctionData(functionFragment: 'isPaused', values?: undefined): string; - encodeFunctionData( - functionFragment: 'messageAttestations', - values: [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, - TransceiverStructs.TransceiverInstructionStruct[], - string[], - ], - ): string; - encodeFunctionData( - functionFragment: 'rateLimitDuration', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'removeTransceiver', - values: [string], - ): string; - encodeFunctionData( - functionFragment: 'setInboundLimit', - values: [BigNumberish, BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'setOutboundLimit', - values: [BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'setPeer', - values: [BigNumberish, BytesLike, BigNumberish, BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'setThreshold', - values: [BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'setTransceiver', - values: [string], - ): string; - encodeFunctionData(functionFragment: 'token', values?: undefined): string; - encodeFunctionData( - functionFragment: 'tokenDecimals', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'tokenDecimals_', - values?: undefined, - ): string; - encodeFunctionData( - functionFragment: 'transceiverAttestedToMessage', - values: [BytesLike, BigNumberish], - ): string; - encodeFunctionData( - functionFragment: 'transfer(uint256,uint16,bytes32)', - values: [BigNumberish, BigNumberish, BytesLike], - ): string; - encodeFunctionData( - functionFragment: 'transfer(uint256,uint16,bytes32,bool,bytes)', - values: [BigNumberish, BigNumberish, BytesLike, boolean, BytesLike], - ): string; - encodeFunctionData( - functionFragment: 'transferOwnership', - values: [string], - ): string; - encodeFunctionData( - functionFragment: 'transferPauserCapability', - values: [string], - ): string; - encodeFunctionData(functionFragment: 'upgrade', values: [string]): string; - - decodeFunctionResult( - functionFragment: 'attestationReceived', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'chainId', data: BytesLike): Result; - decodeFunctionResult( - functionFragment: 'completeInboundQueuedTransfer', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'completeOutboundQueuedTransfer', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'executeMsg', 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: 'getTransceivers', - 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: 'removeTransceiver', - 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: 'tokenDecimals_', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'transceiverAttestedToMessage', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'transfer(uint256,uint16,bytes32)', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'transfer(uint256,uint16,bytes32,bool,bytes)', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'transferOwnership', - data: BytesLike, - ): Result; - decodeFunctionResult( - functionFragment: 'transferPauserCapability', - data: BytesLike, - ): Result; - decodeFunctionResult(functionFragment: 'upgrade', data: BytesLike): Result; - - events: { - 'AdminChanged(address,address)': EventFragment; - 'BeaconUpgraded(address)': EventFragment; - 'InboundTransferQueued(bytes32)': EventFragment; - 'Initialized(uint64)': EventFragment; - 'MessageAlreadyExecuted(bytes32,bytes32)': EventFragment; - 'MessageAttestedTo(bytes32,address,uint8)': EventFragment; - 'NotPaused(bool)': EventFragment; - 'OutboundTransferQueued(uint64)': EventFragment; - 'OutboundTransferRateLimited(address,uint64,uint256,uint256)': EventFragment; - 'OwnershipTransferred(address,address)': EventFragment; - 'Paused(bool)': EventFragment; - 'PauserTransferred(address,address)': EventFragment; - 'PeerUpdated(uint16,bytes32,uint8,bytes32,uint8)': EventFragment; - 'ThresholdChanged(uint8,uint8)': EventFragment; - 'TransceiverAdded(address,uint256,uint8)': EventFragment; - 'TransceiverRemoved(address,uint8)': EventFragment; - 'TransferRedeemed(bytes32)': EventFragment; - 'TransferSent(bytes32,uint256,uint256,uint16,uint64)': EventFragment; - 'Upgraded(address)': EventFragment; - }; - - getEvent(nameOrSignatureOrTopic: 'AdminChanged'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'BeaconUpgraded'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'InboundTransferQueued'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'MessageAlreadyExecuted'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'MessageAttestedTo'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'NotPaused'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'OutboundTransferQueued'): EventFragment; - getEvent( - nameOrSignatureOrTopic: 'OutboundTransferRateLimited', - ): EventFragment; - getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'PauserTransferred'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'PeerUpdated'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'ThresholdChanged'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'TransceiverAdded'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'TransceiverRemoved'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'TransferRedeemed'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'TransferSent'): EventFragment; - getEvent(nameOrSignatureOrTopic: 'Upgraded'): EventFragment; -} - -export interface AdminChangedEventObject { - previousAdmin: string; - newAdmin: string; -} -export type AdminChangedEvent = TypedEvent< - [string, string], - AdminChangedEventObject ->; - -export type AdminChangedEventFilter = TypedEventFilter; - -export interface BeaconUpgradedEventObject { - beacon: string; -} -export type BeaconUpgradedEvent = TypedEvent< - [string], - BeaconUpgradedEventObject ->; - -export type BeaconUpgradedEventFilter = TypedEventFilter; - -export interface InboundTransferQueuedEventObject { - digest: string; -} -export type InboundTransferQueuedEvent = TypedEvent< - [string], - InboundTransferQueuedEventObject ->; - -export type InboundTransferQueuedEventFilter = - TypedEventFilter; - -export interface InitializedEventObject { - version: BigNumber; -} -export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>; - -export type InitializedEventFilter = TypedEventFilter; - -export interface MessageAlreadyExecutedEventObject { - sourceNttManager: string; - msgHash: string; -} -export type MessageAlreadyExecutedEvent = TypedEvent< - [string, string], - MessageAlreadyExecutedEventObject ->; - -export type MessageAlreadyExecutedEventFilter = - TypedEventFilter; - -export interface MessageAttestedToEventObject { - digest: string; - transceiver: string; - index: number; -} -export type MessageAttestedToEvent = TypedEvent< - [string, string, number], - MessageAttestedToEventObject ->; - -export type MessageAttestedToEventFilter = - TypedEventFilter; - -export interface NotPausedEventObject { - notPaused: boolean; -} -export type NotPausedEvent = TypedEvent<[boolean], NotPausedEventObject>; - -export type NotPausedEventFilter = TypedEventFilter; - -export interface OutboundTransferQueuedEventObject { - queueSequence: BigNumber; -} -export type OutboundTransferQueuedEvent = TypedEvent< - [BigNumber], - OutboundTransferQueuedEventObject ->; - -export type OutboundTransferQueuedEventFilter = - TypedEventFilter; - -export interface OutboundTransferRateLimitedEventObject { - sender: string; - sequence: BigNumber; - amount: BigNumber; - currentCapacity: BigNumber; -} -export type OutboundTransferRateLimitedEvent = TypedEvent< - [string, BigNumber, BigNumber, BigNumber], - OutboundTransferRateLimitedEventObject ->; - -export type OutboundTransferRateLimitedEventFilter = - TypedEventFilter; - -export interface OwnershipTransferredEventObject { - previousOwner: string; - newOwner: string; -} -export type OwnershipTransferredEvent = TypedEvent< - [string, string], - OwnershipTransferredEventObject ->; - -export type OwnershipTransferredEventFilter = - TypedEventFilter; - -export interface PausedEventObject { - paused: boolean; -} -export type PausedEvent = TypedEvent<[boolean], PausedEventObject>; - -export type PausedEventFilter = TypedEventFilter; - -export interface PauserTransferredEventObject { - oldPauser: string; - newPauser: string; -} -export type PauserTransferredEvent = TypedEvent< - [string, string], - PauserTransferredEventObject ->; - -export type PauserTransferredEventFilter = - TypedEventFilter; - -export interface PeerUpdatedEventObject { - chainId_: number; - oldPeerContract: string; - oldPeerDecimals: number; - peerContract: string; - peerDecimals: number; -} -export type PeerUpdatedEvent = TypedEvent< - [number, string, number, string, number], - PeerUpdatedEventObject ->; - -export type PeerUpdatedEventFilter = TypedEventFilter; - -export interface ThresholdChangedEventObject { - oldThreshold: number; - threshold: number; -} -export type ThresholdChangedEvent = TypedEvent< - [number, number], - ThresholdChangedEventObject ->; - -export type ThresholdChangedEventFilter = - TypedEventFilter; - -export interface TransceiverAddedEventObject { - transceiver: string; - transceiversNum: BigNumber; - threshold: number; -} -export type TransceiverAddedEvent = TypedEvent< - [string, BigNumber, number], - TransceiverAddedEventObject ->; - -export type TransceiverAddedEventFilter = - TypedEventFilter; - -export interface TransceiverRemovedEventObject { - transceiver: string; - threshold: number; -} -export type TransceiverRemovedEvent = TypedEvent< - [string, number], - TransceiverRemovedEventObject ->; - -export type TransceiverRemovedEventFilter = - TypedEventFilter; - -export interface TransferRedeemedEventObject { - digest: string; -} -export type TransferRedeemedEvent = TypedEvent< - [string], - TransferRedeemedEventObject ->; - -export type TransferRedeemedEventFilter = - TypedEventFilter; - -export interface TransferSentEventObject { - recipient: string; - amount: BigNumber; - fee: BigNumber; - recipientChain: number; - msgSequence: BigNumber; -} -export type TransferSentEvent = TypedEvent< - [string, BigNumber, BigNumber, number, BigNumber], - TransferSentEventObject ->; - -export type TransferSentEventFilter = TypedEventFilter; - -export interface UpgradedEventObject { - implementation: string; -} -export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; - -export type UpgradedEventFilter = TypedEventFilter; - -export interface NttManager extends BaseContract { - connect(signerOrProvider: Signer | Provider | string): this; - attach(addressOrName: string): this; - deployed(): Promise; - - interface: NttManagerInterface; - - queryFilter( - event: TypedEventFilter, - fromBlockOrBlockhash?: string | number | undefined, - toBlock?: string | number | undefined, - ): Promise>; - - listeners( - eventFilter?: TypedEventFilter, - ): Array>; - listeners(eventName?: string): Array; - removeAllListeners( - eventFilter: TypedEventFilter, - ): this; - removeAllListeners(eventName?: string): this; - off: OnEvent; - on: OnEvent; - once: OnEvent; - removeListener: OnEvent; - - functions: { - attestationReceived( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - payload: TransceiverStructs.NttManagerMessageStruct, - overrides?: Overrides & { from?: string }, - ): Promise; - - chainId(overrides?: CallOverrides): Promise<[number]>; - - completeInboundQueuedTransfer( - digest: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - completeOutboundQueuedTransfer( - messageSequence: BigNumberish, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - executeMsg( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - message: TransceiverStructs.NttManagerMessageStruct, - overrides?: Overrides & { from?: string }, - ): Promise; - - getCurrentInboundCapacity( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise<[BigNumber]>; - - getCurrentOutboundCapacity(overrides?: CallOverrides): Promise<[BigNumber]>; - - getInboundLimitParams( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise<[IRateLimiter.RateLimitParamsStructOutput]>; - - getInboundQueuedTransfer( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise<[IRateLimiter.InboundQueuedTransferStructOutput]>; - - getMigratesImmutables(overrides?: CallOverrides): Promise<[boolean]>; - - getMode(overrides?: CallOverrides): Promise<[number]>; - - getOutboundLimitParams( - overrides?: CallOverrides, - ): Promise<[IRateLimiter.RateLimitParamsStructOutput]>; - - getOutboundQueuedTransfer( - queueSequence: BigNumberish, - overrides?: CallOverrides, - ): Promise<[IRateLimiter.OutboundQueuedTransferStructOutput]>; - - getPeer( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise<[INttManagerState.NttManagerPeerStructOutput]>; - - getThreshold(overrides?: CallOverrides): Promise<[number]>; - - getTransceivers( - overrides?: CallOverrides, - ): Promise<[string[]] & { result: string[] }>; - - initialize( - overrides?: Overrides & { from?: string }, - ): Promise; - - isMessageApproved( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise<[boolean]>; - - isMessageExecuted( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise<[boolean]>; - - isPaused(overrides?: CallOverrides): Promise<[boolean]>; - - messageAttestations( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise<[number] & { count: number }>; - - migrate( - overrides?: Overrides & { from?: string }, - ): Promise; - - mode(overrides?: CallOverrides): Promise<[number]>; - - nextMessageSequence(overrides?: CallOverrides): Promise<[BigNumber]>; - - owner(overrides?: CallOverrides): Promise<[string]>; - - pause( - overrides?: Overrides & { from?: string }, - ): Promise; - - pauser(overrides?: CallOverrides): Promise<[string]>; - - quoteDeliveryPrice( - recipientChain: BigNumberish, - transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], - enabledTransceivers: string[], - overrides?: CallOverrides, - ): Promise<[BigNumber[], BigNumber]>; - - rateLimitDuration(overrides?: CallOverrides): Promise<[BigNumber]>; - - removeTransceiver( - transceiver: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - setInboundLimit( - limit: BigNumberish, - chainId_: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setOutboundLimit( - limit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setPeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - decimals: BigNumberish, - inboundLimit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setThreshold( - threshold: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setTransceiver( - transceiver: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - token(overrides?: CallOverrides): Promise<[string]>; - - tokenDecimals(overrides?: CallOverrides): Promise<[number]>; - - tokenDecimals_(overrides?: CallOverrides): Promise<[number]>; - - transceiverAttestedToMessage( - digest: BytesLike, - index: BigNumberish, - overrides?: CallOverrides, - ): Promise<[boolean]>; - - 'transfer(uint256,uint16,bytes32)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - 'transfer(uint256,uint16,bytes32,bool,bytes)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - shouldQueue: boolean, - transceiverInstructions: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - transferOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: Overrides & { from?: string }, - ): Promise; - }; - - attestationReceived( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - payload: TransceiverStructs.NttManagerMessageStruct, - overrides?: Overrides & { from?: string }, - ): Promise; - - chainId(overrides?: CallOverrides): Promise; - - completeInboundQueuedTransfer( - digest: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - completeOutboundQueuedTransfer( - messageSequence: BigNumberish, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - executeMsg( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - message: TransceiverStructs.NttManagerMessageStruct, - overrides?: Overrides & { from?: string }, - ): Promise; - - getCurrentInboundCapacity( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; - - getInboundLimitParams( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getInboundQueuedTransfer( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - getMigratesImmutables(overrides?: CallOverrides): Promise; - - getMode(overrides?: CallOverrides): Promise; - - getOutboundLimitParams( - overrides?: CallOverrides, - ): Promise; - - getOutboundQueuedTransfer( - queueSequence: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getPeer( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getThreshold(overrides?: CallOverrides): Promise; - - getTransceivers(overrides?: CallOverrides): Promise; - - initialize( - overrides?: Overrides & { from?: string }, - ): Promise; - - isMessageApproved( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isMessageExecuted( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isPaused(overrides?: CallOverrides): Promise; - - messageAttestations( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - migrate( - overrides?: Overrides & { from?: string }, - ): Promise; - - mode(overrides?: CallOverrides): Promise; - - nextMessageSequence(overrides?: CallOverrides): Promise; - - owner(overrides?: CallOverrides): Promise; - - pause( - overrides?: Overrides & { from?: string }, - ): Promise; - - pauser(overrides?: CallOverrides): Promise; - - quoteDeliveryPrice( - recipientChain: BigNumberish, - transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], - enabledTransceivers: string[], - overrides?: CallOverrides, - ): Promise<[BigNumber[], BigNumber]>; - - rateLimitDuration(overrides?: CallOverrides): Promise; - - removeTransceiver( - transceiver: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - setInboundLimit( - limit: BigNumberish, - chainId_: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setOutboundLimit( - limit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setPeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - decimals: BigNumberish, - inboundLimit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setThreshold( - threshold: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setTransceiver( - transceiver: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - token(overrides?: CallOverrides): Promise; - - tokenDecimals(overrides?: CallOverrides): Promise; - - tokenDecimals_(overrides?: CallOverrides): Promise; - - transceiverAttestedToMessage( - digest: BytesLike, - index: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - 'transfer(uint256,uint16,bytes32)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - 'transfer(uint256,uint16,bytes32,bool,bytes)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - shouldQueue: boolean, - transceiverInstructions: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - transferOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - callStatic: { - attestationReceived( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - payload: TransceiverStructs.NttManagerMessageStruct, - overrides?: CallOverrides, - ): Promise; - - chainId(overrides?: CallOverrides): Promise; - - completeInboundQueuedTransfer( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - completeOutboundQueuedTransfer( - messageSequence: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - executeMsg( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - message: TransceiverStructs.NttManagerMessageStruct, - overrides?: CallOverrides, - ): Promise; - - getCurrentInboundCapacity( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; - - getInboundLimitParams( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getInboundQueuedTransfer( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - getMigratesImmutables(overrides?: CallOverrides): Promise; - - getMode(overrides?: CallOverrides): Promise; - - getOutboundLimitParams( - overrides?: CallOverrides, - ): Promise; - - getOutboundQueuedTransfer( - queueSequence: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getPeer( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getThreshold(overrides?: CallOverrides): Promise; - - getTransceivers(overrides?: CallOverrides): Promise; - - initialize(overrides?: CallOverrides): Promise; - - isMessageApproved( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isMessageExecuted( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isPaused(overrides?: CallOverrides): Promise; - - messageAttestations( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - migrate(overrides?: CallOverrides): Promise; - - mode(overrides?: CallOverrides): Promise; - - nextMessageSequence(overrides?: CallOverrides): Promise; - - owner(overrides?: CallOverrides): Promise; - - pause(overrides?: CallOverrides): Promise; - - pauser(overrides?: CallOverrides): Promise; - - quoteDeliveryPrice( - recipientChain: BigNumberish, - transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], - enabledTransceivers: string[], - overrides?: CallOverrides, - ): Promise<[BigNumber[], BigNumber]>; - - rateLimitDuration(overrides?: CallOverrides): Promise; - - removeTransceiver( - transceiver: string, - overrides?: CallOverrides, - ): Promise; - - setInboundLimit( - limit: BigNumberish, - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - setOutboundLimit( - limit: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - setPeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - decimals: BigNumberish, - inboundLimit: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - setThreshold( - threshold: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - setTransceiver( - transceiver: string, - overrides?: CallOverrides, - ): Promise; - - token(overrides?: CallOverrides): Promise; - - tokenDecimals(overrides?: CallOverrides): Promise; - - tokenDecimals_(overrides?: CallOverrides): Promise; - - transceiverAttestedToMessage( - digest: BytesLike, - index: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - 'transfer(uint256,uint16,bytes32)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - overrides?: CallOverrides, - ): Promise; - - 'transfer(uint256,uint16,bytes32,bool,bytes)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - shouldQueue: boolean, - transceiverInstructions: BytesLike, - overrides?: CallOverrides, - ): Promise; - - transferOwnership( - newOwner: string, - overrides?: CallOverrides, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: CallOverrides, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: CallOverrides, - ): Promise; - }; - - filters: { - 'AdminChanged(address,address)'( - previousAdmin?: null, - newAdmin?: null, - ): AdminChangedEventFilter; - AdminChanged( - previousAdmin?: null, - newAdmin?: null, - ): AdminChangedEventFilter; - - 'BeaconUpgraded(address)'( - beacon?: string | null, - ): BeaconUpgradedEventFilter; - BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter; - - 'InboundTransferQueued(bytes32)'( - digest?: null, - ): InboundTransferQueuedEventFilter; - InboundTransferQueued(digest?: null): InboundTransferQueuedEventFilter; - - 'Initialized(uint64)'(version?: null): InitializedEventFilter; - Initialized(version?: null): InitializedEventFilter; - - 'MessageAlreadyExecuted(bytes32,bytes32)'( - sourceNttManager?: BytesLike | null, - msgHash?: BytesLike | null, - ): MessageAlreadyExecutedEventFilter; - MessageAlreadyExecuted( - sourceNttManager?: BytesLike | null, - msgHash?: BytesLike | null, - ): MessageAlreadyExecutedEventFilter; - - 'MessageAttestedTo(bytes32,address,uint8)'( - digest?: null, - transceiver?: null, - index?: null, - ): MessageAttestedToEventFilter; - MessageAttestedTo( - digest?: null, - transceiver?: null, - index?: null, - ): MessageAttestedToEventFilter; - - 'NotPaused(bool)'(notPaused?: null): NotPausedEventFilter; - NotPaused(notPaused?: null): NotPausedEventFilter; - - 'OutboundTransferQueued(uint64)'( - queueSequence?: null, - ): OutboundTransferQueuedEventFilter; - OutboundTransferQueued( - queueSequence?: null, - ): OutboundTransferQueuedEventFilter; - - 'OutboundTransferRateLimited(address,uint64,uint256,uint256)'( - sender?: string | null, - sequence?: null, - amount?: null, - currentCapacity?: null, - ): OutboundTransferRateLimitedEventFilter; - OutboundTransferRateLimited( - sender?: string | null, - sequence?: null, - amount?: null, - currentCapacity?: null, - ): OutboundTransferRateLimitedEventFilter; - - 'OwnershipTransferred(address,address)'( - previousOwner?: string | null, - newOwner?: string | null, - ): OwnershipTransferredEventFilter; - OwnershipTransferred( - previousOwner?: string | null, - newOwner?: string | null, - ): OwnershipTransferredEventFilter; - - 'Paused(bool)'(paused?: null): PausedEventFilter; - Paused(paused?: null): PausedEventFilter; - - 'PauserTransferred(address,address)'( - oldPauser?: string | null, - newPauser?: string | null, - ): PauserTransferredEventFilter; - PauserTransferred( - oldPauser?: string | null, - newPauser?: string | null, - ): PauserTransferredEventFilter; - - 'PeerUpdated(uint16,bytes32,uint8,bytes32,uint8)'( - chainId_?: BigNumberish | null, - oldPeerContract?: null, - oldPeerDecimals?: null, - peerContract?: null, - peerDecimals?: null, - ): PeerUpdatedEventFilter; - PeerUpdated( - chainId_?: BigNumberish | null, - oldPeerContract?: null, - oldPeerDecimals?: null, - peerContract?: null, - peerDecimals?: null, - ): PeerUpdatedEventFilter; - - 'ThresholdChanged(uint8,uint8)'( - oldThreshold?: null, - threshold?: null, - ): ThresholdChangedEventFilter; - ThresholdChanged( - oldThreshold?: null, - threshold?: null, - ): ThresholdChangedEventFilter; - - 'TransceiverAdded(address,uint256,uint8)'( - transceiver?: null, - transceiversNum?: null, - threshold?: null, - ): TransceiverAddedEventFilter; - TransceiverAdded( - transceiver?: null, - transceiversNum?: null, - threshold?: null, - ): TransceiverAddedEventFilter; - - 'TransceiverRemoved(address,uint8)'( - transceiver?: null, - threshold?: null, - ): TransceiverRemovedEventFilter; - TransceiverRemoved( - transceiver?: null, - threshold?: null, - ): TransceiverRemovedEventFilter; - - 'TransferRedeemed(bytes32)'( - digest?: BytesLike | null, - ): TransferRedeemedEventFilter; - TransferRedeemed(digest?: BytesLike | null): TransferRedeemedEventFilter; - - 'TransferSent(bytes32,uint256,uint256,uint16,uint64)'( - recipient?: null, - amount?: null, - fee?: null, - recipientChain?: null, - msgSequence?: null, - ): TransferSentEventFilter; - TransferSent( - recipient?: null, - amount?: null, - fee?: null, - recipientChain?: null, - msgSequence?: null, - ): TransferSentEventFilter; - - 'Upgraded(address)'(implementation?: string | null): UpgradedEventFilter; - Upgraded(implementation?: string | null): UpgradedEventFilter; - }; - - estimateGas: { - attestationReceived( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - payload: TransceiverStructs.NttManagerMessageStruct, - overrides?: Overrides & { from?: string }, - ): Promise; - - chainId(overrides?: CallOverrides): Promise; - - completeInboundQueuedTransfer( - digest: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - completeOutboundQueuedTransfer( - messageSequence: BigNumberish, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - executeMsg( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - message: TransceiverStructs.NttManagerMessageStruct, - overrides?: Overrides & { from?: string }, - ): Promise; - - getCurrentInboundCapacity( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getCurrentOutboundCapacity(overrides?: CallOverrides): Promise; - - getInboundLimitParams( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getInboundQueuedTransfer( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - getMigratesImmutables(overrides?: CallOverrides): Promise; - - getMode(overrides?: CallOverrides): Promise; - - getOutboundLimitParams(overrides?: CallOverrides): Promise; - - getOutboundQueuedTransfer( - queueSequence: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getPeer( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getThreshold(overrides?: CallOverrides): Promise; - - getTransceivers(overrides?: CallOverrides): Promise; - - initialize(overrides?: Overrides & { from?: string }): Promise; - - isMessageApproved( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isMessageExecuted( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isPaused(overrides?: CallOverrides): Promise; - - messageAttestations( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - migrate(overrides?: Overrides & { from?: string }): Promise; - - mode(overrides?: CallOverrides): Promise; - - nextMessageSequence(overrides?: CallOverrides): Promise; - - owner(overrides?: CallOverrides): Promise; - - pause(overrides?: Overrides & { from?: string }): Promise; - - pauser(overrides?: CallOverrides): Promise; - - quoteDeliveryPrice( - recipientChain: BigNumberish, - transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], - enabledTransceivers: string[], - overrides?: CallOverrides, - ): Promise; - - rateLimitDuration(overrides?: CallOverrides): Promise; - - removeTransceiver( - transceiver: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - setInboundLimit( - limit: BigNumberish, - chainId_: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setOutboundLimit( - limit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setPeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - decimals: BigNumberish, - inboundLimit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setThreshold( - threshold: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setTransceiver( - transceiver: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - token(overrides?: CallOverrides): Promise; - - tokenDecimals(overrides?: CallOverrides): Promise; - - tokenDecimals_(overrides?: CallOverrides): Promise; - - transceiverAttestedToMessage( - digest: BytesLike, - index: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - 'transfer(uint256,uint16,bytes32)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - 'transfer(uint256,uint16,bytes32,bool,bytes)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - shouldQueue: boolean, - transceiverInstructions: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - transferOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: Overrides & { from?: string }, - ): Promise; - }; - - populateTransaction: { - attestationReceived( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - payload: TransceiverStructs.NttManagerMessageStruct, - overrides?: Overrides & { from?: string }, - ): Promise; - - chainId(overrides?: CallOverrides): Promise; - - completeInboundQueuedTransfer( - digest: BytesLike, - overrides?: Overrides & { from?: string }, - ): Promise; - - completeOutboundQueuedTransfer( - messageSequence: BigNumberish, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - executeMsg( - sourceChainId: BigNumberish, - sourceNttManagerAddress: BytesLike, - message: TransceiverStructs.NttManagerMessageStruct, - overrides?: Overrides & { from?: string }, - ): Promise; - - getCurrentInboundCapacity( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getCurrentOutboundCapacity( - overrides?: CallOverrides, - ): Promise; - - getInboundLimitParams( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getInboundQueuedTransfer( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - getMigratesImmutables( - overrides?: CallOverrides, - ): Promise; - - getMode(overrides?: CallOverrides): Promise; - - getOutboundLimitParams( - overrides?: CallOverrides, - ): Promise; - - getOutboundQueuedTransfer( - queueSequence: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getPeer( - chainId_: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - getThreshold(overrides?: CallOverrides): Promise; - - getTransceivers(overrides?: CallOverrides): Promise; - - initialize( - overrides?: Overrides & { from?: string }, - ): Promise; - - isMessageApproved( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isMessageExecuted( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - isPaused(overrides?: CallOverrides): Promise; - - messageAttestations( - digest: BytesLike, - overrides?: CallOverrides, - ): Promise; - - migrate( - overrides?: Overrides & { from?: string }, - ): Promise; - - mode(overrides?: CallOverrides): Promise; - - nextMessageSequence( - overrides?: CallOverrides, - ): Promise; - - owner(overrides?: CallOverrides): Promise; - - pause( - overrides?: Overrides & { from?: string }, - ): Promise; - - pauser(overrides?: CallOverrides): Promise; - - quoteDeliveryPrice( - recipientChain: BigNumberish, - transceiverInstructions: TransceiverStructs.TransceiverInstructionStruct[], - enabledTransceivers: string[], - overrides?: CallOverrides, - ): Promise; - - rateLimitDuration(overrides?: CallOverrides): Promise; - - removeTransceiver( - transceiver: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - setInboundLimit( - limit: BigNumberish, - chainId_: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setOutboundLimit( - limit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setPeer( - peerChainId: BigNumberish, - peerContract: BytesLike, - decimals: BigNumberish, - inboundLimit: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setThreshold( - threshold: BigNumberish, - overrides?: Overrides & { from?: string }, - ): Promise; - - setTransceiver( - transceiver: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - token(overrides?: CallOverrides): Promise; - - tokenDecimals(overrides?: CallOverrides): Promise; - - tokenDecimals_(overrides?: CallOverrides): Promise; - - transceiverAttestedToMessage( - digest: BytesLike, - index: BigNumberish, - overrides?: CallOverrides, - ): Promise; - - 'transfer(uint256,uint16,bytes32)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - 'transfer(uint256,uint16,bytes32,bool,bytes)'( - amount: BigNumberish, - recipientChain: BigNumberish, - recipient: BytesLike, - shouldQueue: boolean, - transceiverInstructions: BytesLike, - overrides?: PayableOverrides & { from?: string }, - ): Promise; - - transferOwnership( - newOwner: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - transferPauserCapability( - newPauser: string, - overrides?: Overrides & { from?: string }, - ): Promise; - - upgrade( - newImplementation: string, - overrides?: Overrides & { from?: string }, - ): Promise; - }; -} diff --git a/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager__factory.ts b/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager__factory.ts deleted file mode 100644 index e670e34e0..000000000 --- a/wormhole-connect/src/routes/ntt/chains/evm/abis/testnet/NttManager__factory.ts +++ /dev/null @@ -1,1858 +0,0 @@ -/* Autogenerated file. Do not edit manually. */ -/* tslint:disable */ -/* eslint-disable */ -import { - Signer, - utils, - Contract, - ContractFactory, - BigNumberish, - Overrides, -} from 'ethers'; -import type { Provider, TransactionRequest } from '@ethersproject/providers'; -import type { NttManager, NttManagerInterface } from './NttManager'; - -const _abi = [ - { - inputs: [ - { - internalType: 'address', - name: '_token', - type: 'address', - }, - { - internalType: 'enum INttManager.Mode', - name: '_mode', - type: 'uint8', - }, - { - internalType: 'uint16', - name: '_chainId', - type: 'uint16', - }, - { - internalType: 'uint64', - name: '_rateLimitDuration', - type: 'uint64', - }, - { - internalType: 'bool', - name: '_skipRateLimiting', - type: 'bool', - }, - ], - stateMutability: 'nonpayable', - type: 'constructor', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'amount', - type: 'uint256', - }, - ], - name: 'AmountTooLarge', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'burnAmount', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'balanceDiff', - type: 'uint256', - }, - ], - name: 'BurnAmountDifferentThanBalanceDiff', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'caller', - type: 'address', - }, - ], - name: 'CallerNotTransceiver', - type: 'error', - }, - { - inputs: [ - { - internalType: 'TrimmedAmount', - name: 'newCurrentCapacity', - type: 'uint72', - }, - { - internalType: 'TrimmedAmount', - name: 'newLimit', - type: 'uint72', - }, - ], - name: 'CapacityCannotExceedLimit', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'requiredPayment', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'providedPayment', - type: 'uint256', - }, - ], - name: 'DeliveryPaymentTooLow', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'transceiver', - type: 'address', - }, - ], - name: 'DisabledTransceiver', - type: 'error', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - ], - name: 'InboundQueuedTransferNotFound', - type: 'error', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - { - internalType: 'uint256', - name: 'transferTimestamp', - type: 'uint256', - }, - ], - name: 'InboundQueuedTransferStillQueued', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'evmChainId', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'blockChainId', - type: 'uint256', - }, - ], - name: 'InvalidFork', - type: 'error', - }, - { - inputs: [], - name: 'InvalidInitialization', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint8', - name: 'mode', - type: 'uint8', - }, - ], - name: 'InvalidMode', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'account', - type: 'address', - }, - ], - name: 'InvalidPauser', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'peerAddress', - type: 'bytes32', - }, - ], - name: 'InvalidPeer', - type: 'error', - }, - { - inputs: [], - name: 'InvalidPeerChainIdZero', - type: 'error', - }, - { - inputs: [], - name: 'InvalidPeerDecimals', - type: 'error', - }, - { - inputs: [], - name: 'InvalidPeerZeroAddress', - type: 'error', - }, - { - inputs: [], - name: 'InvalidRecipient', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'targetChain', - type: 'uint16', - }, - { - internalType: 'uint16', - name: 'thisChain', - type: 'uint16', - }, - ], - name: 'InvalidTargetChain', - type: 'error', - }, - { - inputs: [], - name: 'InvalidTransceiverZeroAddress', - type: 'error', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'msgHash', - type: 'bytes32', - }, - ], - name: 'MessageNotApproved', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'transceiver', - type: 'address', - }, - ], - name: 'NonRegisteredTransceiver', - type: 'error', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: '', - type: 'bytes32', - }, - ], - name: 'NotAnEvmAddress', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'currentCapacity', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'amount', - type: 'uint256', - }, - ], - name: 'NotEnoughCapacity', - type: 'error', - }, - { - inputs: [], - name: 'NotInitializing', - type: 'error', - }, - { - inputs: [], - name: 'NotMigrating', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint8', - name: 'decimals', - type: 'uint8', - }, - { - internalType: 'uint8', - name: 'decimalsOther', - type: 'uint8', - }, - ], - name: 'NumberOfDecimalsNotEqual', - type: 'error', - }, - { - inputs: [], - name: 'OnlyDelegateCall', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint64', - name: 'queueSequence', - type: 'uint64', - }, - ], - name: 'OutboundQueuedTransferNotFound', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint64', - name: 'queueSequence', - type: 'uint64', - }, - { - internalType: 'uint256', - name: 'transferTimestamp', - type: 'uint256', - }, - ], - name: 'OutboundQueuedTransferStillQueued', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'owner', - type: 'address', - }, - ], - name: 'OwnableInvalidOwner', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'account', - type: 'address', - }, - ], - name: 'OwnableUnauthorizedAccount', - type: 'error', - }, - { - inputs: [], - name: 'ReentrancyGuardReentrantCall', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'refundAmount', - type: 'uint256', - }, - ], - name: 'RefundFailed', - type: 'error', - }, - { - inputs: [], - name: 'RequireContractIsNotPaused', - type: 'error', - }, - { - inputs: [], - name: 'RequireContractIsPaused', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'retrieved', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'registered', - type: 'uint256', - }, - ], - name: 'RetrievedIncorrectRegisteredTransceivers', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'threshold', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'transceivers', - type: 'uint256', - }, - ], - name: 'ThresholdTooHigh', - type: 'error', - }, - { - inputs: [], - name: 'TooManyTransceivers', - type: 'error', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'nttManagerMessageHash', - type: 'bytes32', - }, - ], - name: 'TransceiverAlreadyAttestedToMessage', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'transceiver', - type: 'address', - }, - ], - name: 'TransceiverAlreadyEnabled', - type: 'error', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'amount', - type: 'uint256', - }, - { - internalType: 'uint256', - name: 'dust', - type: 'uint256', - }, - ], - name: 'TransferAmountHasDust', - type: 'error', - }, - { - inputs: [], - name: 'UndefinedRateLimiting', - type: 'error', - }, - { - inputs: [ - { - internalType: 'address', - name: 'expectedOwner', - type: 'address', - }, - { - internalType: 'address', - name: 'owner', - type: 'address', - }, - ], - name: 'UnexpectedDeployer', - type: 'error', - }, - { - inputs: [], - name: 'ZeroAmount', - type: 'error', - }, - { - inputs: [], - name: 'ZeroThreshold', - type: 'error', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'address', - name: 'previousAdmin', - type: 'address', - }, - { - indexed: false, - internalType: 'address', - name: 'newAdmin', - type: 'address', - }, - ], - name: 'AdminChanged', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'beacon', - type: 'address', - }, - ], - name: 'BeaconUpgraded', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - ], - name: 'InboundTransferQueued', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint64', - name: 'version', - type: 'uint64', - }, - ], - name: 'Initialized', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'bytes32', - name: 'sourceNttManager', - type: 'bytes32', - }, - { - indexed: true, - internalType: 'bytes32', - name: 'msgHash', - type: 'bytes32', - }, - ], - name: 'MessageAlreadyExecuted', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - { - indexed: false, - internalType: 'address', - name: 'transceiver', - type: 'address', - }, - { - indexed: false, - internalType: 'uint8', - name: 'index', - type: 'uint8', - }, - ], - name: 'MessageAttestedTo', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bool', - name: 'notPaused', - type: 'bool', - }, - ], - name: 'NotPaused', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint64', - name: 'queueSequence', - type: 'uint64', - }, - ], - name: 'OutboundTransferQueued', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'sender', - type: 'address', - }, - { - indexed: false, - internalType: 'uint64', - name: 'sequence', - type: 'uint64', - }, - { - indexed: false, - internalType: 'uint256', - name: 'amount', - type: 'uint256', - }, - { - indexed: false, - internalType: 'uint256', - name: 'currentCapacity', - type: 'uint256', - }, - ], - name: 'OutboundTransferRateLimited', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'previousOwner', - type: 'address', - }, - { - indexed: true, - internalType: 'address', - name: 'newOwner', - type: 'address', - }, - ], - name: 'OwnershipTransferred', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bool', - name: 'paused', - type: 'bool', - }, - ], - name: 'Paused', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'oldPauser', - type: 'address', - }, - { - indexed: true, - internalType: 'address', - name: 'newPauser', - type: 'address', - }, - ], - name: 'PauserTransferred', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'uint16', - name: 'chainId_', - type: 'uint16', - }, - { - indexed: false, - internalType: 'bytes32', - name: 'oldPeerContract', - type: 'bytes32', - }, - { - indexed: false, - internalType: 'uint8', - name: 'oldPeerDecimals', - type: 'uint8', - }, - { - indexed: false, - internalType: 'bytes32', - name: 'peerContract', - type: 'bytes32', - }, - { - indexed: false, - internalType: 'uint8', - name: 'peerDecimals', - type: 'uint8', - }, - ], - name: 'PeerUpdated', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'uint8', - name: 'oldThreshold', - type: 'uint8', - }, - { - indexed: false, - internalType: 'uint8', - name: 'threshold', - type: 'uint8', - }, - ], - name: 'ThresholdChanged', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'address', - name: 'transceiver', - type: 'address', - }, - { - indexed: false, - internalType: 'uint256', - name: 'transceiversNum', - type: 'uint256', - }, - { - indexed: false, - internalType: 'uint8', - name: 'threshold', - type: 'uint8', - }, - ], - name: 'TransceiverAdded', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'address', - name: 'transceiver', - type: 'address', - }, - { - indexed: false, - internalType: 'uint8', - name: 'threshold', - type: 'uint8', - }, - ], - name: 'TransceiverRemoved', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - ], - name: 'TransferRedeemed', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: false, - internalType: 'bytes32', - name: 'recipient', - type: 'bytes32', - }, - { - indexed: false, - internalType: 'uint256', - name: 'amount', - type: 'uint256', - }, - { - indexed: false, - internalType: 'uint256', - name: 'fee', - type: 'uint256', - }, - { - indexed: false, - internalType: 'uint16', - name: 'recipientChain', - type: 'uint16', - }, - { - indexed: false, - internalType: 'uint64', - name: 'msgSequence', - type: 'uint64', - }, - ], - name: 'TransferSent', - type: 'event', - }, - { - anonymous: false, - inputs: [ - { - indexed: true, - internalType: 'address', - name: 'implementation', - type: 'address', - }, - ], - name: 'Upgraded', - type: 'event', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'sourceChainId', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'sourceNttManagerAddress', - type: 'bytes32', - }, - { - components: [ - { - internalType: 'bytes32', - name: 'id', - type: 'bytes32', - }, - { - internalType: 'bytes32', - name: 'sender', - type: 'bytes32', - }, - { - internalType: 'bytes', - name: 'payload', - type: 'bytes', - }, - ], - internalType: 'struct TransceiverStructs.NttManagerMessage', - name: 'payload', - type: 'tuple', - }, - ], - name: 'attestationReceived', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [], - name: 'chainId', - outputs: [ - { - internalType: 'uint16', - name: '', - type: 'uint16', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - ], - name: 'completeInboundQueuedTransfer', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint64', - name: 'messageSequence', - type: 'uint64', - }, - ], - name: 'completeOutboundQueuedTransfer', - outputs: [ - { - internalType: 'uint64', - name: '', - type: 'uint64', - }, - ], - stateMutability: 'payable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'sourceChainId', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'sourceNttManagerAddress', - type: 'bytes32', - }, - { - components: [ - { - internalType: 'bytes32', - name: 'id', - type: 'bytes32', - }, - { - internalType: 'bytes32', - name: 'sender', - type: 'bytes32', - }, - { - internalType: 'bytes', - name: 'payload', - type: 'bytes', - }, - ], - internalType: 'struct TransceiverStructs.NttManagerMessage', - name: 'message', - type: 'tuple', - }, - ], - name: 'executeMsg', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId_', - type: 'uint16', - }, - ], - name: 'getCurrentInboundCapacity', - outputs: [ - { - internalType: 'uint256', - name: '', - type: 'uint256', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getCurrentOutboundCapacity', - outputs: [ - { - internalType: 'uint256', - name: '', - type: 'uint256', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId_', - type: 'uint16', - }, - ], - name: 'getInboundLimitParams', - outputs: [ - { - components: [ - { - internalType: 'TrimmedAmount', - name: 'limit', - type: 'uint72', - }, - { - internalType: 'TrimmedAmount', - name: 'currentCapacity', - type: 'uint72', - }, - { - internalType: 'uint64', - name: 'lastTxTimestamp', - type: 'uint64', - }, - ], - internalType: 'struct IRateLimiter.RateLimitParams', - name: '', - type: 'tuple', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - ], - name: 'getInboundQueuedTransfer', - outputs: [ - { - components: [ - { - internalType: 'TrimmedAmount', - name: 'amount', - type: 'uint72', - }, - { - internalType: 'uint64', - name: 'txTimestamp', - type: 'uint64', - }, - { - internalType: 'address', - name: 'recipient', - type: 'address', - }, - ], - internalType: 'struct IRateLimiter.InboundQueuedTransfer', - name: '', - type: 'tuple', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getMigratesImmutables', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getMode', - outputs: [ - { - internalType: 'uint8', - name: '', - type: 'uint8', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getOutboundLimitParams', - outputs: [ - { - components: [ - { - internalType: 'TrimmedAmount', - name: 'limit', - type: 'uint72', - }, - { - internalType: 'TrimmedAmount', - name: 'currentCapacity', - type: 'uint72', - }, - { - internalType: 'uint64', - name: 'lastTxTimestamp', - type: 'uint64', - }, - ], - internalType: 'struct IRateLimiter.RateLimitParams', - name: '', - type: 'tuple', - }, - ], - stateMutability: 'pure', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint64', - name: 'queueSequence', - type: 'uint64', - }, - ], - name: 'getOutboundQueuedTransfer', - outputs: [ - { - components: [ - { - internalType: 'bytes32', - name: 'recipient', - type: 'bytes32', - }, - { - internalType: 'TrimmedAmount', - name: 'amount', - type: 'uint72', - }, - { - internalType: 'uint64', - name: 'txTimestamp', - type: 'uint64', - }, - { - internalType: 'uint16', - name: 'recipientChain', - type: 'uint16', - }, - { - internalType: 'address', - name: 'sender', - type: 'address', - }, - { - internalType: 'bytes', - name: 'transceiverInstructions', - type: 'bytes', - }, - ], - internalType: 'struct IRateLimiter.OutboundQueuedTransfer', - name: '', - type: 'tuple', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'chainId_', - type: 'uint16', - }, - ], - name: 'getPeer', - outputs: [ - { - components: [ - { - internalType: 'bytes32', - name: 'peerAddress', - type: 'bytes32', - }, - { - internalType: 'uint8', - name: 'tokenDecimals', - type: 'uint8', - }, - ], - internalType: 'struct INttManagerState.NttManagerPeer', - name: '', - type: 'tuple', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getThreshold', - outputs: [ - { - internalType: 'uint8', - name: '', - type: 'uint8', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'getTransceivers', - outputs: [ - { - internalType: 'address[]', - name: 'result', - type: 'address[]', - }, - ], - stateMutability: 'pure', - type: 'function', - }, - { - inputs: [], - name: 'initialize', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - ], - name: 'isMessageApproved', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - ], - name: 'isMessageExecuted', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'isPaused', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - ], - name: 'messageAttestations', - outputs: [ - { - internalType: 'uint8', - name: 'count', - type: 'uint8', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'migrate', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [], - name: 'mode', - outputs: [ - { - internalType: 'enum INttManager.Mode', - name: '', - type: 'uint8', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'nextMessageSequence', - outputs: [ - { - internalType: 'uint64', - name: '', - type: 'uint64', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'owner', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'pause', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [], - name: 'pauser', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'recipientChain', - type: 'uint16', - }, - { - components: [ - { - internalType: 'uint8', - name: 'index', - type: 'uint8', - }, - { - internalType: 'bytes', - name: 'payload', - type: 'bytes', - }, - ], - internalType: 'struct TransceiverStructs.TransceiverInstruction[]', - name: 'transceiverInstructions', - type: 'tuple[]', - }, - { - internalType: 'address[]', - name: 'enabledTransceivers', - type: 'address[]', - }, - ], - name: 'quoteDeliveryPrice', - outputs: [ - { - internalType: 'uint256[]', - name: '', - type: 'uint256[]', - }, - { - internalType: 'uint256', - name: '', - type: 'uint256', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'rateLimitDuration', - outputs: [ - { - internalType: 'uint64', - name: '', - type: 'uint64', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'transceiver', - type: 'address', - }, - ], - name: 'removeTransceiver', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'limit', - type: 'uint256', - }, - { - internalType: 'uint16', - name: 'chainId_', - type: 'uint16', - }, - ], - name: 'setInboundLimit', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'limit', - type: 'uint256', - }, - ], - name: 'setOutboundLimit', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint16', - name: 'peerChainId', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'peerContract', - type: 'bytes32', - }, - { - internalType: 'uint8', - name: 'decimals', - type: 'uint8', - }, - { - internalType: 'uint256', - name: 'inboundLimit', - type: 'uint256', - }, - ], - name: 'setPeer', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint8', - name: 'threshold', - type: 'uint8', - }, - ], - name: 'setThreshold', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'transceiver', - type: 'address', - }, - ], - name: 'setTransceiver', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [], - name: 'token', - outputs: [ - { - internalType: 'address', - name: '', - type: 'address', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'tokenDecimals', - outputs: [ - { - internalType: 'uint8', - name: '', - type: 'uint8', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [], - name: 'tokenDecimals_', - outputs: [ - { - internalType: 'uint8', - name: '', - type: 'uint8', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'bytes32', - name: 'digest', - type: 'bytes32', - }, - { - internalType: 'uint8', - name: 'index', - type: 'uint8', - }, - ], - name: 'transceiverAttestedToMessage', - outputs: [ - { - internalType: 'bool', - name: '', - type: 'bool', - }, - ], - stateMutability: 'view', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'amount', - type: 'uint256', - }, - { - internalType: 'uint16', - name: 'recipientChain', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'recipient', - type: 'bytes32', - }, - ], - name: 'transfer', - outputs: [ - { - internalType: 'uint64', - name: '', - type: 'uint64', - }, - ], - stateMutability: 'payable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'uint256', - name: 'amount', - type: 'uint256', - }, - { - internalType: 'uint16', - name: 'recipientChain', - type: 'uint16', - }, - { - internalType: 'bytes32', - name: 'recipient', - type: 'bytes32', - }, - { - internalType: 'bool', - name: 'shouldQueue', - type: 'bool', - }, - { - internalType: 'bytes', - name: 'transceiverInstructions', - type: 'bytes', - }, - ], - name: 'transfer', - outputs: [ - { - internalType: 'uint64', - name: '', - type: 'uint64', - }, - ], - stateMutability: 'payable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'newOwner', - type: 'address', - }, - ], - name: 'transferOwnership', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'newPauser', - type: 'address', - }, - ], - name: 'transferPauserCapability', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, - { - inputs: [ - { - internalType: 'address', - name: 'newImplementation', - type: 'address', - }, - ], - name: 'upgrade', - outputs: [], - stateMutability: 'nonpayable', - type: 'function', - }, -] as const; - -const _bytecode = - '0x6101806040523480156200001257600080fd5b5060405162006b4a38038062006b4a833981016040819052620000359162000667565b848484848481816001600160401b03821615801562000052575080155b806200006f57506001600160401b038216158015906200006f5750805b156200008e5760405163e543ef0560e01b815260040160405180910390fd5b506001600160401b0316608052620000a562000122565b620000af6200028e565b3060a0526001600160a01b03851660c052620000ca62000342565b60ff1661016052836001811115620000e657620000e662000701565b610100816001811115620000fe57620000fe62000701565b905250505061ffff16610120525050466101405250503360e05250620007fe915050565b60006200012e620003ee565b905060006200013c62000424565b82548154919250610100900460ff169081146200015d576200015d62000717565b60005b81811015620001b2576200019d8382815481106200018257620001826200072d565b6000918252602090912001546001600160a01b031662000453565b80620001a98162000759565b91505062000160565b5060005b818110156200026e576000620001ce82600162000775565b90505b828110156200025857838181548110620001ef57620001ef6200072d565b60009182526020909120015484546001600160a01b03909116908590849081106200021e576200021e6200072d565b6000918252602090912001546001600160a01b03160362000243576200024362000717565b806200024f8162000759565b915050620001d1565b5080620002658162000759565b915050620001b6565b508254604060ff909116111562000289576200028962000717565b505050565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00805468010000000000000000900460ff1615620002df5760405163f92ee8a960e01b815260040160405180910390fd5b80546001600160401b03908116146200033f5780546001600160401b0319166001600160401b0390811782556040519081527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b50565b60c05160408051600481526024810182526020810180516001600160e01b031663313ce56760e01b179052905160009283926001600160a01b03909116916200038c91906200078b565b600060405180830381855afa9150503d8060008114620003c9576040519150601f19603f3d011682016040523d82523d6000602084013e620003ce565b606091505b5091505080806020019051810190620003e89190620007bc565b91505090565b6000806200041e60017f8561949d1c6242cee5c5a5aeb6b9c190ee611d7742fcec65d9e5b1341ea04d8a620007e8565b92915050565b6000806200041e60017e758a264b9bdbe3295fe36bd6ff7abaa122f48bf70e90af04a1b8a32d21e4e2620007e8565b60006200045f620005f1565b905060006200046d62000621565b905060006200047b620003ee565b905060006200048962000424565b6001600160a01b038616600090815260208681526040918290208251606081018452905460ff8082161515808452610100830482161515948401949094526201000090910416928101929092529192509080620004f957508060200151158015620004f95750604081015160ff16155b62000508576200050862000717565b604081015184546020830151600160ff9093169290921b166001600160401b03161515906000805b8654610100900460ff168110156200059b57896001600160a01b03168682815481106200056157620005616200072d565b6000918252602090912001546001600160a01b0316036200058657600191506200059b565b80620005928162000759565b91505062000530565b5081151583151514620005b257620005b262000717565b81151581151514620005c857620005c862000717565b8554604085015160ff918216911610620005e657620005e662000717565b505050505050505050565b6000806200041e60017f49bca747e973430e858f2f5de357b8dba36ea6d375b81bdb5d53dfaabf0b3a80620007e8565b6000806200041e60017ffd6568c039679b3b7cc93c26c41d9379b7b1bec1677120493b467688302cb120620007e8565b805180151581146200066257600080fd5b919050565b600080600080600060a086880312156200068057600080fd5b85516001600160a01b03811681146200069857600080fd5b602087015190955060028110620006ae57600080fd5b604087015190945061ffff81168114620006c757600080fd5b60608701519093506001600160401b0381168114620006e557600080fd5b9150620006f56080870162000651565b90509295509295909350565b634e487b7160e01b600052602160045260246000fd5b634e487b7160e01b600052600160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b6000600182016200076e576200076e62000743565b5060010190565b808201808211156200041e576200041e62000743565b6000825160005b81811015620007ae576020818601810151858301520162000792565b506000920191825250919050565b600060208284031215620007cf57600080fd5b815160ff81168114620007e157600080fd5b9392505050565b818103818111156200041e576200041e62000743565b60805160a05160c05160e051610100516101205161014051610160516161a4620009a66000396000818161043b0152818161078f0152818161090401528181610a0401528181610a4401528181610ddd01528181611d0001528181611d2101528181611d4501528181611f570152818161286401528181612dce0152818161323e01528181613c1b015281816141df015281816143b501526143ed01526000611ae501526000818161066b01528181611c7a01528181611cca0152613d630152600081816103dd01528181610c92015281816128ba0152818161292c015281816129ea01528181612ca40152613cb1015260008181614156015261419201526000818161086d015281816128fc0152818161298701528181612c0a01528181612c3e01528181612c6d01528181612cef01528181612d5a015281816130660152613b79015260006127960152600081816104a901528181610fdf0152818161162b0152818161200e0152818161208501528181613783015281816138a90152818161390f01528181613dfb015281816144f8015281816146fa015261474a01526161a46000f3fe6080604052600436106102675760003560e01c80638e3ba8c911610144578063b4d591bb116100b6578063e5a986031161007a578063e5a98603146107f1578063e75235b814610811578063f2fde38b14610826578063f5cfec1814610846578063fc0c546a1461085b578063fd96063c1461088f57600080fd5b8063b4d591bb1461071d578063c128d1701461073f578063d72ca9071461077d578063d788c147146107b1578063da4856a1146107d157600080fd5b80639a8a0592116101085780639a8a0592146106595780639d782454146106a05780639f86029c146106c05780639fd0506d146106e0578063a2713356146106f5578063b187bd261461070857600080fd5b80638e3ba8c9146105d05780638fd3ab80146105f057806393acc09e14610605578063961b94d01461063357806397c351461461064657600080fd5b80633b97e856116101dd5780638129fc1c116101a15780638129fc1c146104eb5780638413bcba146105005780638456cb591461052057806386e11ffa1461053557806389c619dd146105835780638da5cb5b146105a357600080fd5b80633b97e8561461042c5780634b4fd03b1461046d578063689f90c31461048257806374aa7bfc146104975780637c918634146104cb57600080fd5b8063190171751161022f57806319017175146103315780631f97c9a814610351578063203e4a9b1461037e57806323d75e311461039e578063295a5212146103cb578063396c16b71461040c57600080fd5b8063027172501461026c578063036de8af1461029f5780630677df54146102c15780630900f010146102f1578063186ce61214610311575b600080fd5b34801561027857600080fd5b5061028c61028736600461525c565b6108ec565b6040519081526020015b60405180910390f35b3480156102ab57600080fd5b506102bf6102ba36600461528e565b61093e565b005b3480156102cd57600080fd5b506102e16102dc3660046152ab565b6109aa565b6040519015158152602001610296565b3480156102fd57600080fd5b506102bf61030c36600461528e565b6109df565b34801561031d57600080fd5b506102bf61032c3660046152c4565b6109f3565b34801561033d57600080fd5b506102bf61034c3660046152ab565b610a33565b34801561035d57600080fd5b5061037161036c366004615309565b610a6e565b6040516102969190615376565b34801561038a57600080fd5b506102bf61039936600461528e565b610bbd565b3480156103aa57600080fd5b506103b3610c57565b6040516001600160401b039091168152602001610296565b3480156103d757600080fd5b506103ff7f000000000000000000000000000000000000000000000000000000000000000081565b60405161029691906153f7565b34801561041857600080fd5b506102e16104273660046152ab565b610c70565b34801561043857600080fd5b507f00000000000000000000000000000000000000000000000000000000000000005b60405160ff9091168152602001610296565b34801561047957600080fd5b5061045b610c8e565b34801561048e57600080fd5b506102e1610cc7565b3480156104a357600080fd5b506103b37f000000000000000000000000000000000000000000000000000000000000000081565b3480156104d757600080fd5b506102bf6104e636600461542e565b610cda565b3480156104f757600080fd5b506102bf610e6a565b34801561050c57600080fd5b506102bf61051b3660046152ab565b610f6c565b34801561052c57600080fd5b506102bf6110b7565b34801561054157600080fd5b5061054a6110cc565b6040805182516001600160481b03908116825260208085015190911690820152918101516001600160401b031690820152606001610296565b34801561058f57600080fd5b5061045b61059e3660046152ab565b611130565b3480156105af57600080fd5b506105b8611149565b6040516001600160a01b039091168152602001610296565b3480156105dc57600080fd5b506102e16105eb366004615476565b611177565b3480156105fc57600080fd5b506102bf6111b1565b34801561061157600080fd5b50610625610620366004615618565b6112b3565b604051610296929190615744565b6103b361064136600461578c565b611431565b6103b3610654366004615309565b6114a8565b34801561066557600080fd5b5061068d7f000000000000000000000000000000000000000000000000000000000000000081565b60405161ffff9091168152602001610296565b3480156106ac57600080fd5b506102bf6106bb3660046157c4565b611749565b3480156106cc57600080fd5b506102bf6106db36600461528e565b611887565b3480156106ec57600080fd5b506105b8611920565b6103b3610703366004615888565b611939565b34801561071457600080fd5b506102e1611998565b34801561072957600080fd5b506107326119ad565b60405161029691906158fd565b34801561074b57600080fd5b5061075f61075a36600461525c565b611a15565b604080518251815260209283015160ff169281019290925201610296565b34801561078957600080fd5b5061045b7f000000000000000000000000000000000000000000000000000000000000000081565b3480156107bd57600080fd5b5061054a6107cc36600461525c565b611a65565b3480156107dd57600080fd5b506102bf6107ec3660046157c4565b611ae0565b3480156107fd57600080fd5b506102bf61080c36600461594a565b611ded565b34801561081d57600080fd5b5061045b611e78565b34801561083257600080fd5b506102bf61084136600461528e565b611e82565b34801561085257600080fd5b5061028c611f45565b34801561086757600080fd5b506105b87f000000000000000000000000000000000000000000000000000000000000000081565b34801561089b57600080fd5b506108af6108aa3660046152ab565b611f90565b6040805182516001600160481b031681526020808401516001600160401b031690820152918101516001600160a01b031690820152606001610296565b6000806109006108fb84611a65565b61200a565b90507f00000000000000000000000000000000000000000000000000000000000000006109366001600160481b03831682612114565b949350505050565b61094e610949611149565b61213e565b6000610958612187565b80546001600160a01b038481166001600160a01b031983168117845560405193945091169182907f51c4874e0f23f262e04a38c51751336dde72126d67f53eb672aaff02996b3ef690600090a3505050565b6000806109b5611e78565b90508060ff166109c484611130565b60ff16101580156109d8575060008160ff16115b9392505050565b6109e76121b5565b6109f0816121e7565b50565b6109fb6121b5565b610a2f610a29837f0000000000000000000000000000000000000000000000000000000000000000806122f5565b82612362565b5050565b610a3b6121b5565b6109f0610a69827f0000000000000000000000000000000000000000000000000000000000000000806122f5565b612387565b6040805160c0810182526000808252602082018190529181018290526060808201839052608082019290925260a0810191909152610aaa612398565b6001600160401b0383811660009081526020928352604090819020815160c0810183528154815260018201546001600160481b03811695820195909552600160481b850490931691830191909152600160881b90920461ffff16606082015260028201546001600160a01b0316608082015260038201805491929160a084019190610b3490615967565b80601f0160208091040260200160405190810160405280929190818152602001828054610b6090615967565b8015610bad5780601f10610b8257610100808354040283529160200191610bad565b820191906000526020600020905b815481529060010190602001808311610b9057829003601f168201915b5050505050815250509050919050565b610bc56121b5565b610bce816123c6565b506000610bd9612678565b805490915060ff16600003610bf457805460ff191660011781555b7ff05962b5774c658e85ed80c91a75af9d66d2af2253dda480f90bce78aff5eda582610c1e6126a6565b548354604080516001600160a01b03909416845261010090920460ff908116602085015216908201526060015b60405180910390a15050565b6000610c616126d4565b546001600160401b0316919050565b6000610c7a612702565b600092835260205250604090205460ff1690565b60007f00000000000000000000000000000000000000000000000000000000000000006001811115610cc257610cc26153e1565b905090565b6000610cd1612730565b5460ff16919050565b610ce26121b5565b8361ffff16600003610d075760405163100b0f2760e11b815260040160405180910390fd5b82610d255760405163f839a0cb60e01b815260040160405180910390fd5b8160ff16600003610d495760405163ade64f0b60e01b815260040160405180910390fd5b6000610d5361275e565b61ffff8616600090815260209182526040908190208151808301909252805482526001015460ff1691810191909152905083610d8d61275e565b61ffff87166000908152602091909152604090205582610dab61275e565b61ffff8716600090815260209190915260409020600101805460ff191660ff92909216919091179055610e08610e02837f0000000000000000000000000000000000000000000000000000000000000000806122f5565b86612362565b80516020808301516040805193845260ff918216928401929092529082018690528416606082015261ffff8616907f1456404e7f41f35c3daac941bb50bad417a66275c3040061b4287d787719599d9060800160405180910390a25050505050565b610e7261278c565b60008051602061614f8339815191528054600160401b810460ff1615906001600160401b0316600081158015610ea55750825b90506000826001600160401b03166001148015610ec15750303b155b905081158015610ecf575080155b15610eed5760405163f92ee8a960e01b815260040160405180910390fd5b845467ffffffffffffffff191660011785558315610f1757845460ff60401b1916600160401b1785555b610f1f6127d5565b8315610f6557845460ff60401b19168555604051600181527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b5050505050565b610f746127ed565b610f7c611998565b15610f9a576040516309e3d0f360e11b815260040160405180910390fd5b6000610fa582611f90565b905080602001516001600160401b0316600003610fdd57604051630301bcaf60e61b8152600481018390526024015b60405180910390fd5b7f00000000000000000000000000000000000000000000000000000000000000006001600160401b031681602001516001600160401b03164261102091906159b7565b10156110575760208101516040516301cb739d60e71b8152600481018490526001600160401b039091166024820152604401610fd4565b61105f612825565b600083815260209190915260409081902080546001600160881b031916815560010180546001600160a01b0319169055810151815161109f918491612853565b506109f0600160008051602061612f83398151915255565b6110c2610949611149565b6110ca612a4d565b565b60408051606081018252600080825260208201819052918101919091526110f1612ab3565b6040805160608101825291546001600160481b038082168452600160481b8204166020840152600160901b90046001600160401b031690820152919050565b600061114361113e83612ae1565b612b1d565b92915050565b7f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300546001600160a01b031690565b600080600160ff84161b611189612702565b600086815260209190915260409020546101009004166001600160401b031611905092915050565b6111b961278c565b6111c1612b50565b6111cc9060016159ca565b60008051602061614f8339815191528054600160401b900460ff16806111ff575080546001600160401b03808416911610155b1561121d5760405163f92ee8a960e01b815260040160405180910390fd5b805468ffffffffffffffffff19166001600160401b03831617600160401b178155611246612b66565b5460ff1661126757604051632866815360e11b815260040160405180910390fd5b61126f6127dd565b805460ff60401b191681556040516001600160401b03831681527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d290602001610c4b565b8051606090600090816112c4612b94565b90506000826001600160401b038111156112e0576112e061549b565b604051908082528060200260200182016040528015611309578160200160208202803683370190505b5090506000805b8481101561142257600088828151811061132c5761132c6159f1565b6020908102919091018101516001600160a01b03811660008181529288905260408320548d5192945062010000900460ff16929163b5634c73908f908f908690811061137a5761137a6159f1565b60200260200101516040518363ffffffff1660e01b815260040161139f929190615a29565b602060405180830381865afa1580156113bc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113e09190615a46565b9050808685815181106113f5576113f56159f1565b602090810291909101015261140a8186615a5f565b9450505050808061141a90615a72565b915050611310565b50909890975095505050505050565b600061143b6127ed565b611443611998565b15611461576040516309e3d0f360e11b815260040160405180910390fd5b60408051600180825281830190925261148f9186918691869160009160208201818036833701905050612bc2565b90506109d8600160008051602061612f83398151915255565b60006114b26127ed565b6114ba611998565b156114d8576040516309e3d0f360e11b815260040160405180910390fd5b60006114e2612398565b6001600160401b0384811660009081526020928352604090819020815160c0810183528154815260018201546001600160481b03811695820195909552600160481b850490931691830191909152600160881b90920461ffff16606082015260028201546001600160a01b0316608082015260038201805491929160a08401919061156c90615967565b80601f016020809104026020016040519081016040528092919081815260200182805461159890615967565b80156115e55780601f106115ba576101008083540402835291602001916115e5565b820191906000526020600020905b8154815290600101906020018083116115c857829003601f168201915b505050505081525050905080604001516001600160401b031660000361162957604051635feafa3160e11b81526001600160401b0384166004820152602401610fd4565b7f00000000000000000000000000000000000000000000000000000000000000006001600160401b031681604001516001600160401b03164261166c91906159b7565b10156116a457604080820151905163c06cf05f60e01b81526001600160401b0380861660048301529091166024820152604401610fd4565b6116ac612398565b6001600160401b03841660009081526020919091526040812081815560018101805472ffffffffffffffffffffffffffffffffffffff191690556002810180546001600160a01b0319169055906117066003830182615202565b505061172a8382602001518360600151846000015185608001518660a00151612efd565b915050611744600160008051602061612f83398151915255565b919050565b611751612b94565b3360009081526020919091526040902054610100900460ff166117895760405163a0ae911d60e01b8152336004820152602401610fd4565b61179383836132ae565b60405163b3f07bbd60e01b815260009073__$93083e246e55d56d98f3df2872cd16bfd0$__9063b3f07bbd906117cf9087908690600401615ab4565b602060405180830381865af41580156117ec573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118109190615a46565b905061183d8161181e612b94565b336000908152602091909152604090205462010000900460ff16611177565b1561185e57604051631089c4a160e11b815260048101829052602401610fd4565b61186881336132f7565b611871816109aa565b1561188157611881848484611ae0565b50505050565b61188f6121b5565b61189881613398565b60006118a2612678565b905060006118ae6126a6565b54825460ff61010090920482169250168110156118d357815460ff191660ff82161782555b8154604080516001600160a01b038616815260ff90921660208301527f697a3853515b88013ad432f29f53d406debc9509ed6d9313dcfe115250fcd18f91015b60405180910390a1505050565b600061192a612187565b546001600160a01b0316919050565b60006119436127ed565b61194b611998565b15611969576040516309e3d0f360e11b815260040160405180910390fd5b6119768686868686612bc2565b905061198f600160008051602061612f83398151915255565b95945050505050565b6000806119a3613660565b5460021492915050565b60606119b761368e565b805480602002602001604051908101604052809291908181526020018280548015611a0b57602002820191906000526020600020905b81546001600160a01b031681526001909101906020018083116119ed575b5050505050905090565b6040805180820190915260008082526020820152611a3161275e565b61ffff909216600090815260209283526040908190208151808301909252805482526001015460ff16928101929092525090565b6040805160608101825260008082526020820181905291810191909152611a8a6136bb565b61ffff9290921660009081526020928352604090819020815160608101835290546001600160481b038082168352600160481b82041694820194909452600160901b9093046001600160401b0316908301525090565b611b097f00000000000000000000000000000000000000000000000000000000000000006136e9565b60405163b3f07bbd60e01b815260009073__$93083e246e55d56d98f3df2872cd16bfd0$__9063b3f07bbd90611b459087908690600401615ab4565b602060405180830381865af4158015611b62573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b869190615a46565b9050611b91816109aa565b611bb157604051630451c4fb60e41b815260048101829052602401610fd4565b6000611bbc82613712565b90508015611bf857604051829085907f4069dff8c9df7e38d2867c0910bd96fd61787695e5380281148c04932d02bef290600090a35050505050565b6040808401519051635399ded560e11b815260009173__$93083e246e55d56d98f3df2872cd16bfd0$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$93083e246e55d56d98f3df2872cd16bfd0$__63b620e8728584516040518363ffffffff1660e01b8152600401612f9f929190615bec565b600060405180830381865af4158015612fbc573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612fe49190810190615c53565b9050600080612ff48984866112b3565b9150915080341015613022576040516306a91e3760e51b815260048101829052346024820152604401610fd4565b600061302e82346159b7565b9050801561303f5761303f8161468c565b5060008b9050600060405180608001604052808d6001600160481b031681526020016130917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690565b81526020018b81526020018c61ffff168152509050600073__$93083e246e55d56d98f3df2872cd16bfd0$__638b4979b86040518060600160405280866001600160401b031660001b81526020016130ef8e6001600160a01b031690565b8152604080516315cfa3cb60e11b815287516001600160481b031660048201526020888101516024830152918801516044820152606088015161ffff16606482015291019073__$93083e246e55d56d98f3df2872cd16bfd0$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'; - -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 deploy( - _token: string, - _mode: BigNumberish, - _chainId: BigNumberish, - _rateLimitDuration: BigNumberish, - _skipRateLimiting: boolean, - overrides?: Overrides & { from?: string }, - ): Promise { - return super.deploy( - _token, - _mode, - _chainId, - _rateLimitDuration, - _skipRateLimiting, - overrides || {}, - ) as Promise; - } - override getDeployTransaction( - _token: string, - _mode: BigNumberish, - _chainId: BigNumberish, - _rateLimitDuration: BigNumberish, - _skipRateLimiting: boolean, - overrides?: Overrides & { from?: string }, - ): TransactionRequest { - return super.getDeployTransaction( - _token, - _mode, - _chainId, - _rateLimitDuration, - _skipRateLimiting, - overrides || {}, - ); - } - override attach(address: string): NttManager { - return super.attach(address) as NttManager; - } - override connect(signer: Signer): NttManager__factory { - return super.connect(signer) as NttManager__factory; - } - - static readonly bytecode = _bytecode; - static readonly abi = _abi; - static createInterface(): NttManagerInterface { - return new utils.Interface(_abi) as NttManagerInterface; - } - static connect( - address: string, - signerOrProvider: Signer | Provider, - ): NttManager { - return new Contract(address, _abi, signerOrProvider) as NttManager; - } -} - -export interface NttManagerLibraryAddresses { - ['src/libraries/TransceiverStructs.sol:TransceiverStructs']: string; -} diff --git a/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts b/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts index 1a434d1f6..65a8ae85a 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/getMessage.ts @@ -21,9 +21,9 @@ import { } from 'utils/ntt'; const RELAYING_INFO_EVENT_TOPIC = - '0x375a56c053c4d19a2e3445e97b7a28bf4e908617ce6d766e1e03a9d3f5276271'; + '0xc3192e083c87c556db539f071d8a298869f487e951327b5616a6f85ae3da958e'; const RELAYING_INFO_IFACE = new ethers.utils.Interface([ - 'event RelayingInfo(uint8 relayingType, uint256 deliveryPayment)', + 'event RelayingInfo(uint8 relayingType, bytes32 refundAddress, uint256 deliveryPayment)', ]); export const getMessageEvm = async ( diff --git a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts index 624b56802..057e58d1c 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts @@ -7,7 +7,7 @@ import { } from '@wormhole-foundation/wormhole-connect-sdk'; import { getTokenById, tryParseErrorMessage } from 'utils'; import { TransferWallet, signAndSendTransaction } from 'utils/wallet'; -import { BaseContract, BigNumber, ethers, PopulatedTransaction } from 'ethers'; +import { BigNumber, ethers, PopulatedTransaction } from 'ethers'; import { InboundQueuedTransfer } from '../../types'; import { InboundQueuedTransferNotFoundError, @@ -20,22 +20,13 @@ import { encodeTransceiverInstructions, encodeWormholeTransceiverInstruction, } from 'routes/ntt/utils'; -import { NttManager as NttManager_testnet } from './abis/testnet/NttManager'; import { NttManager__factory as NttManager__factory_0_1_0 } from './abis/0.1.0/NttManager__factory'; import { NttManager as NttManager_0_1_0 } from './abis/0.1.0/NttManager'; import config from 'config'; import { toChainId, toChainName } from 'utils/sdk'; -import { getNttManagerConfigByAddress } from 'utils/ntt'; const ABI_VERSION_0_1_0 = '0.1.0'; -function isAbiVersion_0_1_0( - version: string, - abi: BaseContract, -): abi is NttManager_0_1_0 { - return version === ABI_VERSION_0_1_0; -} - export class NttManagerEvm { static readonly abiVersionCache = new Map(); @@ -56,42 +47,21 @@ export class NttManagerEvm { return txId; } - // Quotes the delivery price using the wormhole transceiver - async quoteDeliveryPrice( - destChain: ChainName | ChainId, - wormholeTransceiver: string, - ): Promise { - const { abi, version } = await this.getAbi(); - if (isAbiVersion_0_1_0(version, abi)) { - const transceiverIxs = encodeTransceiverInstructions([ - { - index: 0, - payload: encodeWormholeTransceiverInstruction({ - shouldSkipRelayerSend: false, - }), - }, - ]); - const [, deliveryPrice] = await abi.quoteDeliveryPrice( - toChainId(destChain), - transceiverIxs, - ); - return deliveryPrice.toString(); - } else { - const transceiverIxs = [ - { - index: 0, - payload: encodeWormholeTransceiverInstruction({ - shouldSkipRelayerSend: false, - }), - }, - ]; - const [, deliveryPrice] = await ( - abi as NttManager_testnet - ).quoteDeliveryPrice(toChainId(destChain), transceiverIxs, [ - wormholeTransceiver, - ]); - return deliveryPrice.toString(); - } + async quoteDeliveryPrice(destChain: ChainName | ChainId): Promise { + const { abi } = await this.getAbi(); + const transceiverIxs = encodeTransceiverInstructions([ + { + index: 0, + payload: encodeWormholeTransceiverInstruction({ + shouldSkipRelayerSend: false, + }), + }, + ]); + const [, deliveryPrice] = await abi.quoteDeliveryPrice( + toChainId(destChain), + transceiverIxs, + ); + return deliveryPrice.toString(); } async send( @@ -105,18 +75,9 @@ export class NttManagerEvm { const tokenConfig = getTokenById(token); if (!tokenConfig) throw new Error('token not found'); const { abi } = await this.getAbi(); - const nttConfig = getNttManagerConfigByAddress( - this.address, - toChainName(this.chain), - ); - if (!nttConfig || nttConfig.transceivers[0].type !== 'wormhole') - throw new Error('no wormhole transceiver'); - const wormholeTransceiver = nttConfig.transceivers[0].address; const deliveryPrice = shouldSkipRelayerSend ? undefined - : BigNumber.from( - await this.quoteDeliveryPrice(toChain, wormholeTransceiver), - ); + : BigNumber.from(await this.quoteDeliveryPrice(toChain)); const transceiverIxs = encodeTransceiverInstructions([ { index: 0, @@ -125,12 +86,14 @@ export class NttManagerEvm { }), }, ]); + const formattedRecipient = config.wh.formatAddress(recipient, toChain); const tx = await abi.populateTransaction[ - 'transfer(uint256,uint16,bytes32,bool,bytes)' + 'transfer(uint256,uint16,bytes32,bytes32,bool,bytes)' ]( amount, toChainId(toChain), - config.wh.formatAddress(recipient, toChain), + formattedRecipient, + formattedRecipient, // SR gas refund goes to recipient false, // revert instead of getting outbound queued transceiverIxs, { value: deliveryPrice }, @@ -246,17 +209,10 @@ export class NttManagerEvm { } async getAbi(): Promise<{ - abi: NttManager_0_1_0 | NttManager_testnet; + abi: NttManager_0_1_0; version: string; }> { const provider = config.wh.mustGetProvider(this.chain); - // Note: Special case for testnet - //if (!config.isMainnet) { - // return { - // abi: NttManager__factory_testnet.connect(this.address, provider), - // version: 'testnet', - // }; - //} const abiVersionKey = `${this.address}-${toChainName(this.chain)}`; let abiVersion = NttManagerEvm.abiVersionCache.get(abiVersionKey); if (!abiVersion) { diff --git a/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts b/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts index 521e03f6b..89b10e813 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/wormholeTransceiver.ts @@ -47,13 +47,6 @@ export class WormholeTransceiver { version: string; }> { const provider = config.wh.mustGetProvider(this.chain); - // Note: Special case for testnet - if (!config.isMainnet) { - return { - abi: WormholeTransceiver__factory_0_1_0.connect(this.address, provider), - version: ABI_VERSION_0_1_0, - }; - } const abiVersionKey = `${this.address}-${toChainName(this.chain)}`; let abiVersion = WormholeTransceiver.abiVersionCache.get(abiVersionKey); if (!abiVersion) { diff --git a/wormhole-connect/src/routes/ntt/nttRelay.ts b/wormhole-connect/src/routes/ntt/nttRelay.ts index d0d563223..39a8bbdc5 100644 --- a/wormhole-connect/src/routes/ntt/nttRelay.ts +++ b/wormhole-connect/src/routes/ntt/nttRelay.ts @@ -110,10 +110,7 @@ export class NttRelay extends NttBase { const nttManager = new NttManagerEvm(sourceChain, nttManagerAddress); if (nttConfig.transceivers[0].type !== 'wormhole') throw new Error('no wormhole transceiver'); - const deliveryPrice = await nttManager.quoteDeliveryPrice( - destChain, - nttConfig.transceivers[0].address, - ); + const deliveryPrice = await nttManager.quoteDeliveryPrice(destChain); return { fee: BigNumber.from(deliveryPrice), feeToken: 'native' }; } if (toChainName(sourceChain) === 'solana') { diff --git a/wormhole-connect/src/routes/utils.ts b/wormhole-connect/src/routes/utils.ts index 822812ba5..cb68f3f24 100644 --- a/wormhole-connect/src/routes/utils.ts +++ b/wormhole-connect/src/routes/utils.ts @@ -89,7 +89,7 @@ export const isIlliquidDestToken = ( } if ( symbol === 'USDC' && - nativeChain === 'sepolia' && + nativeChain === 'fuji' && destChain === 'alfajores' ) { return true; From 7dda5f1d70aeb16c6afbd3b86350defe47f2df94 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Tue, 2 Apr 2024 09:36:32 -0500 Subject: [PATCH 13/17] delivery price wormhole fee for manual xfers fix --- .../src/routes/ntt/chains/evm/nttManager.ts | 16 ++++++++++------ wormhole-connect/src/routes/ntt/nttRelay.ts | 7 +++++-- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts index 057e58d1c..0b10aca4a 100644 --- a/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts +++ b/wormhole-connect/src/routes/ntt/chains/evm/nttManager.ts @@ -47,13 +47,16 @@ export class NttManagerEvm { return txId; } - async quoteDeliveryPrice(destChain: ChainName | ChainId): Promise { + async quoteDeliveryPrice( + destChain: ChainName | ChainId, + shouldSkipRelayerSend: boolean, + ): Promise { const { abi } = await this.getAbi(); const transceiverIxs = encodeTransceiverInstructions([ { index: 0, payload: encodeWormholeTransceiverInstruction({ - shouldSkipRelayerSend: false, + shouldSkipRelayerSend, }), }, ]); @@ -61,7 +64,7 @@ export class NttManagerEvm { toChainId(destChain), transceiverIxs, ); - return deliveryPrice.toString(); + return deliveryPrice; } async send( @@ -75,9 +78,10 @@ export class NttManagerEvm { const tokenConfig = getTokenById(token); if (!tokenConfig) throw new Error('token not found'); const { abi } = await this.getAbi(); - const deliveryPrice = shouldSkipRelayerSend - ? undefined - : BigNumber.from(await this.quoteDeliveryPrice(toChain)); + const deliveryPrice = await this.quoteDeliveryPrice( + toChain, + shouldSkipRelayerSend, + ); const transceiverIxs = encodeTransceiverInstructions([ { index: 0, diff --git a/wormhole-connect/src/routes/ntt/nttRelay.ts b/wormhole-connect/src/routes/ntt/nttRelay.ts index 39a8bbdc5..18de73d29 100644 --- a/wormhole-connect/src/routes/ntt/nttRelay.ts +++ b/wormhole-connect/src/routes/ntt/nttRelay.ts @@ -110,8 +110,11 @@ export class NttRelay extends NttBase { const nttManager = new NttManagerEvm(sourceChain, nttManagerAddress); if (nttConfig.transceivers[0].type !== 'wormhole') throw new Error('no wormhole transceiver'); - const deliveryPrice = await nttManager.quoteDeliveryPrice(destChain); - return { fee: BigNumber.from(deliveryPrice), feeToken: 'native' }; + const deliveryPrice = await nttManager.quoteDeliveryPrice( + destChain, + false, + ); + return { fee: deliveryPrice, feeToken: 'native' }; } if (toChainName(sourceChain) === 'solana') { if (!nttConfig.solanaQuoter) throw new Error('no solana quoter'); From 6ed4a7c486c1c9e94059de590f79fa4386c95b08 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Tue, 2 Apr 2024 09:37:31 -0500 Subject: [PATCH 14/17] removed comment --- wormhole-connect/src/routes/ntt/nttBase.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/wormhole-connect/src/routes/ntt/nttBase.ts b/wormhole-connect/src/routes/ntt/nttBase.ts index 861532b55..153806361 100644 --- a/wormhole-connect/src/routes/ntt/nttBase.ts +++ b/wormhole-connect/src/routes/ntt/nttBase.ts @@ -253,7 +253,6 @@ export abstract class NttBase extends BaseRoute { throw new Error('Amount too low'); } const shouldSkipRelayerSend = this.TYPE !== Route.NttRelay; - // TODO: will change with https://github.com/wormhole-foundation/example-native-token-transfers/pull/326 refund address return await nttManager.send( token, senderAddress, From edf3b76cd2e3d7f22ba2f280d9d2c902191c3808 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Tue, 2 Apr 2024 10:09:21 -0500 Subject: [PATCH 15/17] removed old testnet ntt token configs --- wormhole-connect/src/config/testnet/tokens.ts | 80 ------------------- 1 file changed, 80 deletions(-) diff --git a/wormhole-connect/src/config/testnet/tokens.ts b/wormhole-connect/src/config/testnet/tokens.ts index fcea2e9ff..612393cc5 100644 --- a/wormhole-connect/src/config/testnet/tokens.ts +++ b/wormhole-connect/src/config/testnet/tokens.ts @@ -2262,84 +2262,4 @@ export const TESTNET_TOKENS: TokensConfig = { default: 18, }, }, - TEST_NTTsepolia: { - key: 'TEST_NTTsepolia', - symbol: 'TEST_NTT', - nativeChain: 'sepolia', - icon: Icon.NTT, - tokenId: { - chain: 'sepolia', - address: '0x1d30E78B7C7fbbcef87ae6e97B5389b2e470CA4a', - }, - coinGeckoId: '', - color: '#2774CA', - decimals: { - Ethereum: 18, - default: 8, - }, - }, - TEST_NTTarbitrum_sepolia: { - key: 'TEST_NTTarbitrum_sepolia', - symbol: 'TEST_NTT', - nativeChain: 'arbitrum_sepolia', - icon: Icon.NTT, - tokenId: { - chain: 'arbitrum_sepolia', - address: '0x84A1Cb660B19eB0063EE5FD377eC14AAe3364d74', - }, - coinGeckoId: '', - color: '#2774CA', - decimals: { - Ethereum: 18, - default: 8, - }, - }, - TEST_NTTbase_sepolia: { - key: 'TEST_NTTbase_sepolia', - symbol: 'TEST_NTT', - nativeChain: 'base_sepolia', - icon: Icon.NTT, - tokenId: { - chain: 'base_sepolia', - address: '0x7f430D4e7939D994C0955A01FC75D9DE33F12D11', - }, - coinGeckoId: '', - color: '#2774CA', - decimals: { - Ethereum: 18, - default: 8, - }, - }, - TEST_NTToptimism_sepolia: { - key: 'TEST_NTToptimism_sepolia', - symbol: 'TEST_NTT', - nativeChain: 'optimism_sepolia', - icon: Icon.NTT, - tokenId: { - chain: 'optimism_sepolia', - address: '0x0e15979a7a1eFAEf20312CA45A59eb141bF7E340', - }, - coinGeckoId: '', - color: '#2774CA', - decimals: { - Ethereum: 18, - default: 8, - }, - }, - TEST_NTTsolana: { - key: 'TEST_NTTsolana', - symbol: 'TEST_NTT', - nativeChain: 'solana', - icon: Icon.NTT, - tokenId: { - chain: 'solana', - address: '87r5ZS91Q2pQbFTvvneqs7y7mbtegtqMt4LDAS4g23Ax', - }, - coinGeckoId: '', - color: '#2774CA', - decimals: { - Solana: 9, - default: 8, - }, - }, }; From f5c6458e5d9a678612b469dbc17f0347ddb5ca02 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Tue, 2 Apr 2024 11:29:12 -0500 Subject: [PATCH 16/17] Added NTT to README --- README.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/README.md b/README.md index c57916793..6c7039ca8 100644 --- a/README.md +++ b/README.md @@ -131,6 +131,21 @@ See the "Arbitrary Token" example in [the config docs](https://docs.wormhole.com Please note you have to [register a token](https://portalbridge.com/advanced-tools/#/register) with the token bridge before you can use it in Connect. +### Configuring Custom NTT (Native Token Transfer) Groups +To configure custom NTT groups, include an `nttGroups` key in your configuration. + +```ts +const config: WormholeConnectConfig = { + nttGroups: { + // Your custom NTT groups go here + } +} +``` + +For a practical example of how to structure your custom NTT groups, refer to the [nttGroups.ts](https://github.com/wormhole-foundation/wormhole-connect/blob/development/wormhole-connect/src/config/testnet/nttGroups.ts) file. + +Please note that the `tokenKey` specified in your custom NTT group must correspond to an existing entry in the tokensConfig, whether it's a built-in or a custom token. + ### Custom Theme You can also customize Connect's color scheme by providing a `WormholeConnectTheme` as the `theme` prop. From 3d6db9ad532dc4476060889bae83d80adedafbd8 Mon Sep 17 00:00:00 2001 From: Kevin Peters Date: Thu, 4 Apr 2024 12:42:21 -0500 Subject: [PATCH 17/17] Added Fantom bridged USDC NTT addresses --- .../src/config/mainnet/gasEstimates.ts | 14 +++++++++ .../src/config/mainnet/nttGroups.ts | 29 ++++++++++++++++++- wormhole-connect/src/config/mainnet/tokens.ts | 15 ++++++++++ wormhole-connect/src/routes/ntt/nttBase.ts | 2 +- wormhole-connect/src/routes/utils.ts | 16 +++++++--- 5 files changed, 70 insertions(+), 6 deletions(-) diff --git a/wormhole-connect/src/config/mainnet/gasEstimates.ts b/wormhole-connect/src/config/mainnet/gasEstimates.ts index d2bdf33f5..dbfe4c18d 100644 --- a/wormhole-connect/src/config/mainnet/gasEstimates.ts +++ b/wormhole-connect/src/config/mainnet/gasEstimates.ts @@ -32,6 +32,13 @@ export const MAINNET_GAS_ESTIMATES: GasEstimates = { sendToken: 300000, claim: 450000, }, + [Route.NttManual]: { + sendToken: 10000000, + claim: 10000000, + }, + [Route.NttRelay]: { + sendToken: 10000000, + }, }, polygon: { [Route.Bridge]: { @@ -107,6 +114,13 @@ export const MAINNET_GAS_ESTIMATES: GasEstimates = { sendNative: 250000, sendToken: 300000, }, + [Route.NttManual]: { + sendToken: 10000000, + claim: 10000000, + }, + [Route.NttRelay]: { + sendToken: 10000000, + }, }, celo: { [Route.Bridge]: { diff --git a/wormhole-connect/src/config/mainnet/nttGroups.ts b/wormhole-connect/src/config/mainnet/nttGroups.ts index 3f02588ed..9727df37f 100644 --- a/wormhole-connect/src/config/mainnet/nttGroups.ts +++ b/wormhole-connect/src/config/mainnet/nttGroups.ts @@ -1,3 +1,30 @@ import { NttGroups } from 'config/types'; -export const MAINNET_NTT_GROUPS: NttGroups = {}; +export const MAINNET_NTT_GROUPS: NttGroups = { + FANTOM_USDC: { + nttManagers: [ + { + chainName: 'ethereum', + address: '0xeBdCe9a913d9400EE75ef31Ce8bd34462D01a1c1', + tokenKey: 'USDCeth', + transceivers: [ + { + address: '0x55f7820357FA17A1ECb48E959D5E637bFF956d6F', + type: 'wormhole', + }, + ], + }, + { + chainName: 'fantom', + address: '0x68dB2f05Aa2d77DEf981fd2be32661340c9222FB', + tokenKey: 'USDCfantom', + transceivers: [ + { + address: '0x8b47f02e7e20174c76af910adc0ad8a4b0342f4c', + type: 'wormhole', + }, + ], + }, + ], + }, +}; diff --git a/wormhole-connect/src/config/mainnet/tokens.ts b/wormhole-connect/src/config/mainnet/tokens.ts index 3f97eb4e3..213edc655 100644 --- a/wormhole-connect/src/config/mainnet/tokens.ts +++ b/wormhole-connect/src/config/mainnet/tokens.ts @@ -1126,6 +1126,21 @@ export const MAINNET_TOKENS: TokensConfig = { }, }, }, + USDCfantom: { + key: 'USDCfantom', + symbol: 'USDC.e', + nativeChain: 'fantom', + icon: Icon.USDC, + tokenId: { + chain: 'fantom', + address: '0x2F733095B80A04b38b0D10cC884524a3d09b836a', + }, + coinGeckoId: 'usd-coin', + color: '#2774CA', + decimals: { + default: 6, + }, + }, CELO: { key: 'CELO', symbol: 'CELO', diff --git a/wormhole-connect/src/routes/ntt/nttBase.ts b/wormhole-connect/src/routes/ntt/nttBase.ts index 153806361..0392fe58f 100644 --- a/wormhole-connect/src/routes/ntt/nttBase.ts +++ b/wormhole-connect/src/routes/ntt/nttBase.ts @@ -184,7 +184,7 @@ export abstract class NttBase extends BaseRoute { routeOptions?: any, ): Promise { if (isEvmChain(sendingChain)) { - const gasLimit = this.TYPE === Route.NttManual ? 200_000 : 250_000; + const gasLimit = this.TYPE === Route.NttManual ? 250_000 : 300_000; return await estimateAverageGasFee(sendingChain, gasLimit); } else if (toChainName(sendingChain) === 'solana') { return BigNumber.from(10_000); diff --git a/wormhole-connect/src/routes/utils.ts b/wormhole-connect/src/routes/utils.ts index cb68f3f24..a05f1b8fc 100644 --- a/wormhole-connect/src/routes/utils.ts +++ b/wormhole-connect/src/routes/utils.ts @@ -87,17 +87,25 @@ export const isIlliquidDestToken = ( return true; } } + // Users should send USDC to Fantom via NTT instead of the token bridge if ( symbol === 'USDC' && - nativeChain === 'fuji' && - destChain === 'alfajores' + nativeChain === 'ethereum' && + destChain === 'fantom' ) { return true; } - if (symbol === 'USDC.e' && nativeChain === 'alfajores') { + if ( + symbol === 'USDC' && + nativeChain === 'fuji' && + destChain === 'alfajores' + ) { return true; } - if (['TEST_NTT', 'USDCalfaljores'].includes(symbol)) { + if ( + symbol === 'USDC.e' && + (nativeChain === 'fantom' || nativeChain === 'alfajores') + ) { return true; } return false;