@galacticcouncil/xc-cfg 0.1.0

package/build/types/builders/extrinsics/xcm/polkadotXcm.utils.d.ts

@@ -0,0 +1,322 @@
+import { ChainEcosystem, Parachain, TxWeight } from '@galacticcouncil/xc-core';
+import { XcmTransferType, XcmVersion } from './types';
+export declare const toDest: (version: XcmVersion, source: Parachain, destination: Parachain) => {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X2: ({
+                GlobalConsensus: ChainEcosystem | undefined;
+                Parachain?: undefined;
+            } | {
+                Parachain: number;
+                GlobalConsensus?: undefined;
+            })[];
+        };
+    };
+} | {
+    [x: string]: {
+        parents: number;
+        interior: string;
+    };
+} | {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X1: any;
+        };
+    };
+};
+export declare const toBeneficiary: (version: XcmVersion, account: any) => {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X1: any;
+        };
+    };
+};
+export declare const toTransferType: (version: XcmVersion, type: XcmTransferType, assetLocation: any) => XcmTransferType.Teleport | XcmTransferType.LocalReserve | XcmTransferType.DestinationReserve | {
+    RemoteReserve: {
+        [x: string]: any;
+    };
+};
+export declare const toAsset: (assetLocation: object, amount: any) => {
+    id: object;
+    fun: {
+        Fungible: any;
+    };
+};
+export declare const toDepositXcmOnDest: (version: XcmVersion, account: any) => {
+    [x: string]: {
+        DepositAsset: {
+            assets: {
+                Wild: {
+                    AllCounted: number;
+                };
+            };
+            beneficiary: {
+                parents: number;
+                interior: {
+                    X1: any;
+                };
+            };
+        };
+    }[];
+};
+/**
+ * Instructions are executed in 2 steps:
+ *
+ * 1) SetAppendix - Error Handling, return everything to sender on Asset hub
+ * 2) InitiateReserveWithdraw - Initiate the bridged transfer
+ *
+ * @param version - XCM Version
+ * @param account - destination account (receiver)
+ * @param sender - sender account
+ * @param transferAssetLocation - transfer asset xcm location
+ * @returns xcm ethereum bridge instructions
+ */
+export declare const toBridgeXcmOnDest: (version: XcmVersion, account: any, sender: any, transferAssetLocation: object, messageId: string | undefined) => {
+    [x: string]: ({
+        SetAppendix: {
+            DepositAsset: {
+                assets: {
+                    Wild: string;
+                };
+                beneficiary: {
+                    parents: number;
+                    interior: {
+                        X1: any;
+                    };
+                };
+            };
+        }[];
+        InitiateReserveWithdraw?: undefined;
+        SetTopic?: undefined;
+    } | {
+        InitiateReserveWithdraw: {
+            assets: {
+                Wild: {
+                    AllOf: {
+                        id: object;
+                        fun: string;
+                    };
+                };
+            };
+            reserve: {
+                parents: number;
+                interior: {
+                    X1: {
+                        GlobalConsensus: {
+                            Ethereum: {
+                                chain_id: number;
+                            };
+                        };
+                    }[];
+                };
+            };
+            xcm: ({
+                BuyExecution: {
+                    fees: {
+                        id: {
+                            parents: number;
+                            interior: {
+                                X1: any;
+                                Here?: undefined;
+                            };
+                        } | {
+                            parents: number;
+                            interior: {
+                                Here: null;
+                                X1?: undefined;
+                            };
+                        };
+                        fun: {
+                            Fungible: number;
+                        };
+                    };
+                    weightLimit: string;
+                };
+                DepositAsset?: undefined;
+                SetTopic?: undefined;
+            } | {
+                DepositAsset: {
+                    assets: {
+                        Wild: {
+                            AllCounted: number;
+                        };
+                    };
+                    beneficiary: {
+                        parents: number;
+                        interior: {
+                            X1: any;
+                        };
+                    };
+                };
+                BuyExecution?: undefined;
+                SetTopic?: undefined;
+            } | {
+                SetTopic: string | undefined;
+                BuyExecution?: undefined;
+                DepositAsset?: undefined;
+            })[];
+        };
+        SetAppendix?: undefined;
+        SetTopic?: undefined;
+    } | {
+        SetTopic: string | undefined;
+        SetAppendix?: undefined;
+        InitiateReserveWithdraw?: undefined;
+    })[];
+};
+/**
+ * Instructions are executed in 3 steps:
+ *
+ * 1) WithdrawAsset - Withdraw fee asset from the target account
+ * 2) BuyExecution - Buy execution with the fee asset
+ * 3) Transact - Destination (Transact) chain call execution
+ *
+ * Note that DepositAsset using AllCounted and not All, since All
+ * has too high of a gas requirement.
+ *
+ * @param version - XCM Version
+ * @param account - destination account (receiver)
+ * @param transactFeeLocation - transact fee xcm location
+ * @param transactFeeAmount - transact fee amount
+ * @param transactCall - transact calldata
+ * @param transactWeight - transact weight
+ * @returns xcm transact message instructions
+ */
+export declare const toTransactMessage: (version: XcmVersion, account: any, transactFeeLocation: object, transactFeeAmount: any, transactCall: `0x${string}`, transactWeight: TxWeight) => {
+    [x: string]: ({
+        WithdrawAsset: {
+            id: object;
+            fun: {
+                Fungible: any;
+            };
+        }[];
+        BuyExecution?: undefined;
+        Transact?: undefined;
+        RefundSurplus?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        BuyExecution: {
+            fees: {
+                id: object;
+                fun: {
+                    Fungible: any;
+                };
+            };
+            weightLimit: string;
+        };
+        WithdrawAsset?: undefined;
+        Transact?: undefined;
+        RefundSurplus?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        Transact: {
+            originKind: string;
+            requireWeightAtMost: TxWeight;
+            call: {
+                encoded: `0x${string}`;
+            };
+        };
+        WithdrawAsset?: undefined;
+        BuyExecution?: undefined;
+        RefundSurplus?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        RefundSurplus: {};
+        WithdrawAsset?: undefined;
+        BuyExecution?: undefined;
+        Transact?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        DepositAsset: {
+            assets: {
+                Wild: {
+                    AllCounted: number;
+                };
+            };
+            beneficiary: {
+                parents: number;
+                interior: {
+                    X1: any;
+                };
+            };
+        };
+        WithdrawAsset?: undefined;
+        BuyExecution?: undefined;
+        Transact?: undefined;
+        RefundSurplus?: undefined;
+    })[];
+};
+export declare const toTransferMessage: (version: XcmVersion, account: any, transferAssetLocation: object, transferAssetAmount: any, transferFeeAmount: any, receiver: any) => {
+    [x: string]: ({
+        WithdrawAsset: {
+            id: object;
+            fun: {
+                Fungible: any;
+            };
+        }[];
+        BuyExecution?: undefined;
+        TransferAsset?: undefined;
+        RefundSurplus?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        BuyExecution: {
+            fees: {
+                id: object;
+                fun: {
+                    Fungible: any;
+                };
+            };
+            weightLimit: string;
+        };
+        WithdrawAsset?: undefined;
+        TransferAsset?: undefined;
+        RefundSurplus?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        TransferAsset: {
+            assets: {
+                id: object;
+                fun: {
+                    Fungible: any;
+                };
+            }[];
+            beneficiary: {
+                parents: number;
+                interior: {
+                    X1: any;
+                };
+            };
+        };
+        WithdrawAsset?: undefined;
+        BuyExecution?: undefined;
+        RefundSurplus?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        RefundSurplus: {};
+        WithdrawAsset?: undefined;
+        BuyExecution?: undefined;
+        TransferAsset?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        DepositAsset: {
+            assets: {
+                Wild: {
+                    AllCounted: number;
+                };
+            };
+            beneficiary: {
+                parents: number;
+                interior: {
+                    X1: any;
+                };
+            };
+        };
+        WithdrawAsset?: undefined;
+        BuyExecution?: undefined;
+        TransferAsset?: undefined;
+        RefundSurplus?: undefined;
+    })[];
+};

package/build/types/builders/extrinsics/xcm/types.d.ts

@@ -0,0 +1,18 @@
+export declare enum XcmVersion {
+    v1 = "V1",
+    v2 = "V2",
+    v3 = "V3",
+    v4 = "V4",
+    v5 = "V5"
+}
+export declare enum XcmTransferType {
+    Teleport = "Teleport",
+    LocalReserve = "LocalReserve",
+    DestinationReserve = "DestinationReserve",
+    RemoteReserve = "RemoteReserve"
+}
+export type Parents = 0 | 1 | 2;
+/**
+ * Encoding mode for the XcmEncoder (typed API vs unsafe API)
+ */
+export type EncodingMode = 'typed' | 'unsafe';

package/build/types/builders/extrinsics/xcm/utils/account.d.ts

@@ -0,0 +1,14 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+export declare function getExtrinsicAccount(address: string): {
+    AccountKey20: {
+        key: string;
+    };
+    AccountId32?: undefined;
+} | {
+    AccountId32: {
+        id: string;
+        network: null;
+    };
+    AccountKey20?: undefined;
+};
+export declare function getDerivativeAccount(from: Parachain, fromAddress: string, to: Parachain): string;

package/build/types/builders/extrinsics/xcm/utils/fee.d.ts

@@ -0,0 +1 @@
+export declare function shouldFeeAssetPrecede(transferAssetLocation: any, transferFeeLocation: any): boolean;

package/build/types/builders/extrinsics/xcm/utils/guard.d.ts

@@ -0,0 +1,4 @@
+import { Asset, Parachain } from '@galacticcouncil/xc-core';
+export declare function locationOrError(chain: Parachain, asset: Asset): {
+    [x: string]: any;
+};

package/build/types/builders/extrinsics/xcm/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './account';
+export * from './fee';
+export * from './guard';
+export * as instr from './instructions';
+export * from './location';

package/build/types/builders/extrinsics/xcm/utils/instructions.d.ts

@@ -0,0 +1,65 @@
+export declare const ETHER_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare function bridgeLocation(ethChainId: number): {
+    parents: number;
+    interior: {
+        X1: {
+            GlobalConsensus: {
+                Ethereum: {
+                    chain_id: number;
+                };
+            };
+        }[];
+    };
+};
+export declare function parachainLocation(paraId: number): {
+    parents: number;
+    interior: {
+        X1: {
+            Parachain: number;
+        }[];
+    };
+};
+export declare function erc20Location(ethChainId: number, tokenAddress: string): {
+    parents: number;
+    interior: {
+        X1: {
+            GlobalConsensus: {
+                Ethereum: {
+                    chain_id: number;
+                };
+            };
+        }[];
+    };
+} | {
+    parents: number;
+    interior: {
+        X2: ({
+            GlobalConsensus: {
+                Ethereum: {
+                    chain_id: number;
+                };
+            };
+        } | {
+            AccountKey20: {
+                key: string;
+            };
+        })[];
+    };
+};
+export declare function erc20LocationReanchored(tokenAddress: string): {
+    parents: number;
+    interior: {
+        here: null;
+        X1?: undefined;
+    };
+} | {
+    parents: number;
+    interior: {
+        X1: {
+            AccountKey20: {
+                key: string;
+            };
+        }[];
+        here?: undefined;
+    };
+};

package/build/types/builders/extrinsics/xcm/utils/location.d.ts

@@ -0,0 +1,12 @@
+import { XcmVersion } from '../types';
+/**
+ * Get extrinsic X1 interior
+ *
+ * @param assetLocation - asset xcm location
+ * @param version - xcm version
+ * @returns normalized x1 interior if version prior to V4
+ */
+export declare function getExtrinsicAssetLocation(assetLocation: Record<string, any>, version: XcmVersion): Record<string, any> | {
+    Concrete: {};
+};
+export declare function getX1Junction(version: XcmVersion, junction: any): any;

package/build/types/builders/extrinsics/xcm/xTokens.d.ts

@@ -0,0 +1,7 @@
+import { ExtrinsicConfigBuilder } from '@galacticcouncil/xc-core';
+export declare const xTokens: () => {
+    transfer: () => ExtrinsicConfigBuilder;
+    transferMultiasset: () => ExtrinsicConfigBuilder;
+    transferMultiassets: () => ExtrinsicConfigBuilder;
+    transferMultiCurrencies: () => ExtrinsicConfigBuilder;
+};

package/build/types/builders/extrinsics/xcm/xTokens.utils.d.ts

@@ -0,0 +1,23 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+import { XcmVersion } from './types';
+export declare const toDest: (version: XcmVersion, destination: Parachain, account: any) => {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X1: any;
+        };
+    };
+} | {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X2: any[];
+        };
+    };
+};
+export declare const toAsset: (assetLocation: object, amount: any) => {
+    id: object;
+    fun: {
+        Fungible: any;
+    };
+};

package/build/types/builders/extrinsics/xcm/xTransfer.d.ts

@@ -0,0 +1,4 @@
+import { ExtrinsicConfigBuilder } from '@galacticcouncil/xc-core';
+export declare const xTransfer: () => {
+    transfer: () => ExtrinsicConfigBuilder;
+};

package/build/types/builders/extrinsics/xcm/xTransfer.utils.d.ts

@@ -0,0 +1,13 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+export declare const toDest: (destination: Parachain, account: any) => {
+    parents: number;
+    interior: {
+        X2: any[];
+    };
+};
+export declare const toAsset: (assetLocation: object, amount: any) => {
+    id: object;
+    fun: {
+        Fungible: any;
+    };
+};

package/build/types/builders/extrinsics/xcm/xcmPallet.d.ts

@@ -0,0 +1,11 @@
+import { ExtrinsicConfigBuilder } from '@galacticcouncil/xc-core';
+import { XcmTransferType } from './types';
+type TransferOpts = {
+    transferType: XcmTransferType;
+};
+export declare const xcmPallet: () => {
+    limitedReserveTransferAssets: () => ExtrinsicConfigBuilder;
+    limitedTeleportAssets: () => ExtrinsicConfigBuilder;
+    transferAssetsUsingTypeAndThen: (opts: TransferOpts) => ExtrinsicConfigBuilder;
+};
+export {};

package/build/types/builders/extrinsics/xcm/xcmPallet.utils.d.ts

@@ -0,0 +1,24 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+import { XcmVersion } from './types';
+export declare const toDest: (version: XcmVersion, destination: Parachain) => {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X1: any;
+        };
+    };
+};
+export declare const toAsset: (assetLocation: object, amount: any) => {
+    id: object;
+    fun: {
+        Fungible: any;
+    };
+};
+export declare const toBeneficiary: (version: XcmVersion, account: any) => {
+    [x: string]: {
+        parents: number;
+        interior: {
+            X1: any;
+        };
+    };
+};

package/build/types/builders/index.d.ts

@@ -0,0 +1,9 @@
+export * from './AssetMinBuilder';
+export * from './BalanceBuilder';
+export * from './ContractBuilder';
+export * from './ExtrinsicBuilder';
+export * from './FeeAmountBuilder';
+export * from './FeeAssetBuilder';
+export * from './ProgramBuilder';
+export * from './MoveBuilder';
+export { XcmVersion, XcmTransferType } from './extrinsics/xcm';

package/build/types/builders/moves/Wormhole/TokenBridge.d.ts

@@ -0,0 +1,10 @@
+import { EvmParachain, MoveConfigBuilder } from '@galacticcouncil/xc-core';
+type TransferMrlOpts = {
+    moonchain: EvmParachain;
+};
+export declare const TokenBridge: () => {
+    transferNativeWithPayload: () => {
+        viaMrl: (opts: TransferMrlOpts) => MoveConfigBuilder;
+    };
+};
+export {};

package/build/types/builders/moves/Wormhole/index.d.ts

@@ -0,0 +1,9 @@
+export declare function Wormhole(): {
+    TokenBridge: () => {
+        transferNativeWithPayload: () => {
+            viaMrl: (opts: {
+                moonchain: import("@galacticcouncil/xc-core").EvmParachain;
+            }) => import("@galacticcouncil/xc-core").MoveConfigBuilder;
+        };
+    };
+};

package/build/types/builders/programs/Wormhole/TokenBridge.d.ts

@@ -0,0 +1,13 @@
+import { EvmParachain, ProgramConfigBuilder } from '@galacticcouncil/xc-core';
+type TransferMrlOpts = {
+    moonchain: EvmParachain;
+};
+export declare const TokenBridge: () => {
+    transferNativeWithPayload: () => {
+        viaMrl: (opts: TransferMrlOpts) => ProgramConfigBuilder;
+    };
+    transferTokenWithPayload: () => {
+        viaMrl: (opts: TransferMrlOpts) => ProgramConfigBuilder;
+    };
+};
+export {};

package/build/types/builders/programs/Wormhole/index.d.ts

@@ -0,0 +1,14 @@
+export declare function Wormhole(): {
+    TokenBridge: () => {
+        transferNativeWithPayload: () => {
+            viaMrl: (opts: {
+                moonchain: import("@galacticcouncil/xc-core").EvmParachain;
+            }) => import("@galacticcouncil/xc-core").ProgramConfigBuilder;
+        };
+        transferTokenWithPayload: () => {
+            viaMrl: (opts: {
+                moonchain: import("@galacticcouncil/xc-core").EvmParachain;
+            }) => import("@galacticcouncil/xc-core").ProgramConfigBuilder;
+        };
+    };
+};

package/build/types/builders/utils/amount.d.ts

@@ -0,0 +1 @@
+export declare function padFeeByPercentage(fee: bigint, padPercent: bigint): bigint;

package/build/types/builders/utils/asset.d.ts

@@ -0,0 +1,2 @@
+import { ChainAssetId } from '@galacticcouncil/xc-core';
+export declare function parseAssetId(assetId: ChainAssetId): ChainAssetId;

package/build/types/builders/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './amount';
+export * from './asset';

package/build/types/chains/chains.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/chains/evm/index.d.ts

@@ -0,0 +1,4 @@
+import { AnyChain } from '@galacticcouncil/xc-core';
+import { ethereum } from './mainnet';
+export declare const evmChains: AnyChain[];
+export { ethereum };

package/build/types/chains/evm/mainnet.d.ts

@@ -0,0 +1,2 @@
+import { EvmChain } from '@galacticcouncil/xc-core';
+export declare const ethereum: EvmChain;

package/build/types/chains/index.d.ts

@@ -0,0 +1,8 @@
+import { AnyChain } from '@galacticcouncil/xc-core';
+export declare const chains: AnyChain[];
+export declare const chainsMap: Map<string, AnyChain>;
+export * from './evm';
+export * from './polkadot';
+export * from './solana';
+export * from './sui';
+export * from './kusama';

package/build/types/chains/kusama/assethub.d.ts

@@ -0,0 +1,2 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+export declare const kusamaAssetHub: Parachain;

package/build/types/chains/kusama/basilisk.d.ts

@@ -0,0 +1,2 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+export declare const basilisk: Parachain;

package/build/types/chains/kusama/index.d.ts

@@ -0,0 +1,10 @@
+import { AnyChain } from '@galacticcouncil/xc-core';
+import { kusamaAssetHub } from './assethub';
+import { basilisk } from './basilisk';
+import { integritee } from './integritee';
+import { karura } from './karura';
+import { kusama } from './kusama';
+import { robonomics } from './robonomics';
+import { tinkernet } from './tinkernet';
+export declare const kusamaChains: AnyChain[];
+export { kusama, kusamaAssetHub, basilisk, integritee, karura, robonomics, tinkernet, };

package/build/types/chains/kusama/integritee.d.ts

@@ -0,0 +1,2 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+export declare const integritee: Parachain;

package/build/types/chains/kusama/karura.d.ts

@@ -0,0 +1,2 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+export declare const karura: Parachain;

package/build/types/chains/kusama/kusama.d.ts

@@ -0,0 +1,2 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+export declare const kusama: Parachain;

package/build/types/chains/kusama/robonomics.d.ts

@@ -0,0 +1,2 @@
+import { Parachain } from '@galacticcouncil/xc-core';
+export declare const robonomics: Parachain;