@moonbeam-network/xcm-builder 2.6.2 → 3.0.0

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2022 PureStake
+Copyright 2024 Moonbeam Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/build/index.d.mts

@@ -0,0 +1,619 @@
+import { Chain, AnyParachain, AssetAmount, ChainAssetId, ChainAsset, AnyChain, EvmParachain } from '@moonbeam-network/xcm-types';
+import { ApiPromise } from '@polkadot/api';
+import { FrameSystemAccountInfo, StagingXcmV3MultiLocation } from '@polkadot/types/lookup';
+import { Struct, u128, Enum } from '@polkadot/types';
+import { Abi, PublicClient, HttpTransport } from 'viem';
+import { SubmittableExtrinsicFunction } from '@polkadot/api/types';
+import { HexString } from '@polkadot/util/types';
+import { Wormhole, Network } from '@wormhole-foundation/sdk-connect';
+
+interface ConfigBuilder<Config, Params = BuilderParams> {
+    build: (params: Params) => Config;
+}
+interface BuilderParams<IChain extends Chain = AnyParachain> {
+    asset: AssetAmount;
+    destination: IChain;
+    destinationAddress: string;
+    destinationApi?: ApiPromise;
+    fee: AssetAmount;
+    source: IChain;
+    sourceAddress: string;
+    sourceApi?: ApiPromise;
+}
+
+interface BaseConfigConstructorParams {
+    module: string;
+    func: string;
+}
+declare class BaseConfig {
+    readonly module: string;
+    readonly func: string;
+    constructor({ module, func }: BaseConfigConstructorParams);
+}
+
+interface QueryConfigConstructorParams extends BaseConfigConstructorParams {
+    args?: unknown[];
+    transform: (data: any) => Promise<bigint>;
+}
+declare class SubstrateQueryConfig extends BaseConfig {
+    readonly args: unknown[];
+    readonly transform: (data: unknown) => Promise<bigint>;
+    static is(obj: unknown): obj is SubstrateQueryConfig;
+    constructor({ args, transform, ...other }: QueryConfigConstructorParams);
+}
+
+type AssetMinConfigBuilder = ConfigBuilder<SubstrateQueryConfig, AssetMinConfigBuilderParams>;
+interface AssetMinConfigBuilderParams {
+    address?: string;
+    asset: ChainAssetId;
+}
+
+declare function AssetMinBuilder(): {
+    assetRegistry: typeof assetRegistry;
+    assets: typeof assets$1;
+    foreignAssets: typeof foreignAssets$1;
+};
+declare function assetRegistry(): {
+    assetMetadatas: () => AssetMinConfigBuilder;
+    currencyMetadatas: () => AssetMinConfigBuilder;
+};
+declare function assets$1(): {
+    asset: () => AssetMinConfigBuilder;
+};
+declare function foreignAssets$1(): {
+    asset: () => AssetMinConfigBuilder;
+};
+
+interface ContractConfigConstructorParams extends BaseConfigConstructorParams {
+    address: string;
+    abi: Abi;
+    args: any[];
+}
+declare class ContractConfig extends BaseConfig {
+    readonly address: string;
+    readonly abi: Abi;
+    readonly args: any[];
+    static is(obj: unknown): obj is ContractConfig;
+    constructor({ address, abi, args, ...other }: ContractConfigConstructorParams);
+    encodeFunctionData(): `0x${string}`;
+}
+
+type ContractConfigBuilder = ConfigBuilder<ContractConfig>;
+
+declare function Xtokens(): {
+    transfer: (weight?: bigint) => ContractConfigBuilder;
+    transferMultiCurrencies: (shouldTransferAssetPrecedeFeeAsset?: boolean, weight?: bigint) => ContractConfigBuilder;
+    transferWithEvmTo32: (weight?: bigint) => ContractConfigBuilder;
+};
+
+declare function ContractBuilder(): {
+    Xtokens: typeof Xtokens;
+};
+
+type EvmQueryFunctions = 'getBalance';
+type EvmFunctionArgs = Parameters<PublicClient<HttpTransport>[EvmQueryFunctions]>;
+interface EvmQueryConfigParams {
+    readonly args: EvmFunctionArgs;
+    readonly func: EvmQueryFunctions;
+}
+declare class EvmQueryConfig {
+    readonly args: EvmFunctionArgs;
+    readonly func: EvmQueryFunctions;
+    static is(obj: unknown): obj is EvmQueryConfig;
+    constructor({ args, func }: EvmQueryConfigParams);
+}
+
+type BalanceConfigBuilder = ConfigBuilder<ContractConfig | SubstrateQueryConfig | EvmQueryConfig, BalanceBuilderParams>;
+interface BalanceBuilderParams {
+    address: string;
+    asset: ChainAsset;
+}
+interface PalletBalancesAccountDataOld extends Struct {
+    readonly free: u128;
+    readonly reserved: u128;
+    readonly miscFrozen: u128;
+    readonly feeFrozen: u128;
+}
+interface TokensPalletAccountData {
+    free: u128;
+    reserved: u128;
+    frozen: u128;
+}
+type EquilibriumSystemBalanceData = Array<[
+    number,
+    {
+        positive: number;
+    }
+]>;
+
+declare function BalanceBuilder(): {
+    evm: typeof evm;
+    substrate: typeof substrate;
+};
+declare function evm(): {
+    erc20: typeof erc20;
+    native: typeof native;
+};
+declare function erc20(): BalanceConfigBuilder;
+declare function native(): BalanceConfigBuilder;
+declare function substrate(): {
+    assets: typeof assets;
+    foreignAssets: typeof foreignAssets;
+    system: typeof system;
+    tokens: typeof tokens;
+};
+declare function assets(): {
+    account: () => BalanceConfigBuilder;
+};
+declare function foreignAssets(): {
+    account: () => BalanceConfigBuilder;
+};
+declare function system(): {
+    account: () => BalanceConfigBuilder;
+    accountEquilibrium: () => BalanceConfigBuilder;
+    accountEvmTo32: () => BalanceConfigBuilder;
+};
+declare function tokens(): {
+    accounts: () => BalanceConfigBuilder;
+};
+declare function calculateSystemAccountBalance(response: FrameSystemAccountInfo): Promise<bigint>;
+
+declare const ERC20_ABI: readonly [{
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "name";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_spender";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_from";
+        readonly type: "address";
+    }, {
+        readonly name: "_to";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [{
+        readonly name: "_owner";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly name: "balance";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_to";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [{
+        readonly name: "_owner";
+        readonly type: "address";
+    }, {
+        readonly name: "_spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly payable: true;
+    readonly stateMutability: "payable";
+    readonly type: "fallback";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}];
+
+interface ExtrinsicConfigConstructorParams extends Omit<BaseConfigConstructorParams, 'type'> {
+    getArgs: (func?: SubmittableExtrinsicFunction<'promise'>) => any[];
+}
+declare class ExtrinsicConfig extends BaseConfig {
+    getArgs: (func?: SubmittableExtrinsicFunction<'promise'>) => any[];
+    static is(obj: unknown): obj is ExtrinsicConfig;
+    constructor({ getArgs, ...other }: ExtrinsicConfigConstructorParams);
+}
+
+type ExtrinsicConfigBuilder = ConfigBuilder<ExtrinsicConfig>;
+declare enum XcmVersion {
+    v1 = "V1",
+    v2 = "V2",
+    v3 = "V3",
+    v4 = "V4",
+    v5 = "V5"
+}
+type Parents = 0 | 1;
+
+declare function eqBalances(): {
+    xcmTransfer: () => ExtrinsicConfigBuilder;
+    transferXcm: () => ExtrinsicConfigBuilder;
+};
+
+declare function polkadotXcm$1(): {
+    limitedReserveTransferAssets: () => {
+        here: () => ExtrinsicConfigBuilder;
+        X1: () => ExtrinsicConfigBuilder;
+        X2: () => ExtrinsicConfigBuilder;
+    };
+    limitedReserveWithdrawAssets: () => {
+        X2: () => ExtrinsicConfigBuilder;
+    };
+    transferAssets: () => {
+        here: () => ExtrinsicConfigBuilder;
+        X2AndFeeHere: () => ExtrinsicConfigBuilder;
+    };
+    transferAssetsUsingTypeAndThen: () => {
+        globalConsensusEthereum: () => ExtrinsicConfigBuilder;
+    };
+};
+
+declare function xTokens(): {
+    transfer: () => ExtrinsicConfigBuilder;
+    transferMultiAsset: (originParachainId: number) => {
+        here: () => ExtrinsicConfigBuilder;
+        X1: () => ExtrinsicConfigBuilder;
+        X2: () => ExtrinsicConfigBuilder;
+    };
+    transferMultiCurrencies: () => ExtrinsicConfigBuilder;
+};
+
+declare function xTransfer(): {
+    transfer: () => {
+        here: () => ExtrinsicConfigBuilder;
+        X2: () => ExtrinsicConfigBuilder;
+    };
+};
+
+declare function xcmPallet(): {
+    limitedReserveTransferAssets: (parents?: Parents) => {
+        here: () => ExtrinsicConfigBuilder;
+    };
+    transferAssetsUsingTypeAndThen: () => {
+        here: () => ExtrinsicConfigBuilder;
+    };
+};
+
+declare function ExtrinsicBuilder(): {
+    eqBalances: typeof eqBalances;
+    xTokens: typeof xTokens;
+    xTransfer: typeof xTransfer;
+    polkadotXcm: typeof polkadotXcm$1;
+    xcmPallet: typeof xcmPallet;
+};
+
+interface SubstrateCallConfigConstructorParams {
+    api: ApiPromise;
+    call: () => Promise<bigint>;
+}
+declare class SubstrateCallConfig {
+    readonly api: ApiPromise;
+    readonly call: () => Promise<any>;
+    static is(obj: unknown): obj is SubstrateCallConfig;
+    constructor({ api, call }: SubstrateCallConfigConstructorParams);
+}
+
+type FeeConfigBuilder = ConfigBuilder<SubstrateCallConfig, FeeConfigBuilderParams>;
+interface FeeConfigBuilderParams {
+    address: string;
+    api: ApiPromise;
+    asset: ChainAsset;
+    destination: AnyParachain;
+    feeAsset: ChainAsset;
+}
+interface XcmPaymentFeeProps {
+    isAssetReserveChain: boolean;
+    shouldTransferAssetPrecedeFeeAsset?: boolean;
+}
+interface MoonbeamRuntimeXcmConfigAssetType extends Enum {
+    readonly isXcm: boolean;
+    readonly asXcm: StagingXcmV3MultiLocation;
+    readonly type: 'Xcm';
+}
+
+declare function FeeBuilder(): {
+    xcmPaymentApi: typeof xcmPaymentApi;
+};
+declare function xcmPaymentApi(): {
+    xcmPaymentFee: ({ isAssetReserveChain, shouldTransferAssetPrecedeFeeAsset, }: XcmPaymentFeeProps) => FeeConfigBuilder;
+};
+
+declare function wormhole$1(): {
+    tokenTransfer: () => MrlConfigBuilder;
+};
+
+type WormholeTransferFunctions = 'tokenTransfer';
+type WormholeFunctionArgs = Parameters<Wormhole<Network>[WormholeTransferFunctions]>;
+interface WormholeConfigConstructorParams {
+    args: WormholeFunctionArgs;
+    func: WormholeTransferFunctions;
+}
+declare class WormholeConfig {
+    readonly args: WormholeFunctionArgs;
+    readonly func: WormholeTransferFunctions;
+    static is(obj: unknown): obj is WormholeConfig;
+    constructor({ args, func }: WormholeConfigConstructorParams);
+}
+
+declare function wormholeFactory(chain: AnyChain): Wormhole<"Mainnet" | "Testnet">;
+
+type MrlConfigBuilder = ConfigBuilder<ContractConfig | ExtrinsicConfig | WormholeConfig, MrlBuilderParams>;
+type MrlExecuteConfigBuilder = ConfigBuilder<ContractConfig, MrlExecuteBuilderParams>;
+interface MrlBuilderParams extends BuilderParams<AnyChain> {
+    isAutomatic: boolean;
+    moonApi: ApiPromise;
+    moonAsset: ChainAsset;
+    moonChain: EvmParachain;
+    moonGasLimit?: bigint;
+    sendOnlyRemoteExecution?: boolean;
+    transact?: Transact;
+}
+interface MrlExecuteBuilderParams {
+    bytes?: Uint8Array;
+}
+interface Transact {
+    call: HexString;
+    txWeight: {
+        refTime: bigint;
+        proofSize: bigint;
+    };
+}
+
+declare function Batch(): {
+    transferAssetsAndMessage: () => MrlConfigBuilder;
+};
+
+declare function Gmp(): {
+    wormholeTransferERC20: () => MrlExecuteConfigBuilder;
+};
+
+declare function TokenBridge(): {
+    transferTokens: () => MrlConfigBuilder;
+};
+
+declare function TokenBridgeRelayer(): {
+    transferTokensWithRelay: () => MrlConfigBuilder;
+};
+
+declare function contract(): {
+    Batch: typeof Batch;
+    Gmp: typeof Gmp;
+    TokenBridge: typeof TokenBridge;
+    TokenBridgeRelayer: typeof TokenBridgeRelayer;
+};
+
+declare function ethereumXcm(): {
+    transact: () => MrlConfigBuilder;
+};
+
+declare function polkadotXcm(): {
+    send: () => MrlConfigBuilder;
+};
+
+declare function extrinsic(): {
+    ethereumXcm: typeof ethereumXcm;
+    polkadotXcm: typeof polkadotXcm;
+};
+
+declare const BATCH_CONTRACT_ABI: readonly [{
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "index";
+        readonly type: "uint256";
+    }];
+    readonly name: "SubcallFailed";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "index";
+        readonly type: "uint256";
+    }];
+    readonly name: "SubcallSucceeded";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "to";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "value";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "callData";
+        readonly type: "bytes[]";
+    }, {
+        readonly internalType: "uint64[]";
+        readonly name: "gasLimit";
+        readonly type: "uint64[]";
+    }];
+    readonly name: "batchAll";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "to";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "value";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "callData";
+        readonly type: "bytes[]";
+    }, {
+        readonly internalType: "uint64[]";
+        readonly name: "gasLimit";
+        readonly type: "uint64[]";
+    }];
+    readonly name: "batchSome";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "to";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "value";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "callData";
+        readonly type: "bytes[]";
+    }, {
+        readonly internalType: "uint64[]";
+        readonly name: "gasLimit";
+        readonly type: "uint64[]";
+    }];
+    readonly name: "batchSomeUntilFailure";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+
+declare function wormhole(): {
+    contract: typeof contract;
+    extrinsic: typeof extrinsic;
+    wormhole: typeof wormhole$1;
+};
+
+declare function MrlBuilder(): {
+    wormhole: typeof wormhole;
+};
+
+declare const BATCH_CONTRACT_ADDRESS = "0x0000000000000000000000000000000000000808";
+
+export { AssetMinBuilder, type AssetMinConfigBuilder, type AssetMinConfigBuilderParams, BATCH_CONTRACT_ABI, BATCH_CONTRACT_ADDRESS, BalanceBuilder, type BalanceBuilderParams, type BalanceConfigBuilder, type BuilderParams, type ConfigBuilder, ContractBuilder, ContractConfig, type ContractConfigBuilder, type ContractConfigConstructorParams, ERC20_ABI, type EquilibriumSystemBalanceData, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type MoonbeamRuntimeXcmConfigAssetType, MrlBuilder, type MrlBuilderParams, type MrlConfigBuilder, type MrlExecuteBuilderParams, type MrlExecuteConfigBuilder, type PalletBalancesAccountDataOld, type Parents, type QueryConfigConstructorParams, SubstrateCallConfig, type SubstrateCallConfigConstructorParams, SubstrateQueryConfig, type TokensPalletAccountData, type Transact, WormholeConfig, type WormholeConfigConstructorParams, type WormholeFunctionArgs, type WormholeTransferFunctions, type XcmPaymentFeeProps, XcmVersion, calculateSystemAccountBalance, evm, substrate, wormhole, wormholeFactory };