@galacticcouncil/xc-core 0.1.0

package/build/types/chain/Parachain.d.ts

@@ -0,0 +1,75 @@
+import { PolkadotClient } from 'polkadot-api';
+import { Asset } from '../asset';
+import { Chain, ChainAssetData, ChainAssetId, ChainCurrency, ChainParams, ChainType } from './Chain';
+/**
+ * Type for XCM multi-location objects (JSON-serializable)
+ */
+type XcmLocation = Record<string, any>;
+/**
+ * XCM Version enum
+ */
+export declare enum XcmVersion {
+    v1 = "V1",
+    v2 = "V2",
+    v3 = "V3",
+    v4 = "V4",
+    v5 = "V5"
+}
+/**
+ * Parachain Asset Data
+ *
+ * @interface ParachainAssetsData
+ * @member {ChainAssetId} metadataId asset id to query metadata (if other than internal)
+ * @member {ChainAssetId} minId asset id to query minimal deposit (if other than internal)
+ * @member {XcmLocation} xcmLocation asset xcm location
+ */
+export interface ParachainAssetData extends ChainAssetData {
+    metadataId?: ChainAssetId;
+    minId?: ChainAssetId;
+    xcmLocation?: XcmLocation;
+}
+export interface ParachainParams extends ChainParams<ParachainAssetData> {
+    genesisHash: string;
+    parachainId: number;
+    ss58Format: number;
+    treasury?: string;
+    usesChainDecimals?: boolean;
+    usesCexForwarding?: boolean;
+    usesDeliveryFee?: boolean;
+    usesSignerFee?: boolean;
+    usesH160Acc?: boolean;
+    ws: string | string[];
+    xcmVersion?: XcmVersion;
+}
+export declare class Parachain extends Chain<ParachainAssetData> {
+    readonly genesisHash: string;
+    readonly parachainId: number;
+    readonly ss58Format: number;
+    readonly treasury: string | undefined;
+    readonly usesChainDecimals: boolean;
+    readonly usesCexForwarding: boolean;
+    readonly usesDeliveryFee: boolean;
+    readonly usesSignerFee: boolean;
+    readonly usesH160Acc: boolean;
+    readonly ws: string | string[];
+    readonly xcmVersion: XcmVersion;
+    constructor({ genesisHash, parachainId, ss58Format, treasury, usesChainDecimals, usesCexForwarding, usesDeliveryFee, usesSignerFee, usesH160Acc, ws, xcmVersion, ...others }: ParachainParams);
+    /**
+     * Get XCM version for a specific pallet call by inspecting runtime metadata via PAPI
+     * This dynamically detects which XCM versions are supported by the pallet
+     *
+     * @param pallet - Pallet name (e.g., 'xTokens', 'polkadotXcm')
+     * @param method - Method name (e.g., 'transfer', 'transferMultiasset')
+     * @param argIndex - Index of the argument to inspect (usually the dest/beneficiary param)
+     * @returns Promise<XcmVersion> - Detected XCM version
+     */
+    getXcmVersionForCall(pallet: string, method: string, argIndex?: number): Promise<XcmVersion>;
+    get api(): PolkadotClient;
+    getType(): ChainType;
+    getCurrency(): Promise<ChainCurrency>;
+    getAssetXcmLocation(asset: Asset): XcmLocation | undefined;
+    getMetadataAssetId(asset: Asset): ChainAssetId;
+    getMinAssetId(asset: Asset): ChainAssetId;
+    findAssetById(id: string): ParachainAssetData | undefined;
+}
+export {};

package/build/types/chain/SolanaChain.d.ts

@@ -0,0 +1,17 @@
+import { Connection } from '@solana/web3.js';
+import { Chain, ChainAssetData, ChainCurrency, ChainParams, ChainRpcs, ChainType } from './Chain';
+import { Wormhole, WormholeDef } from '../bridge';
+export interface SolanaChainParams extends ChainParams<ChainAssetData> {
+    id: number;
+    rpcUrls: ChainRpcs;
+    wormhole?: WormholeDef;
+}
+export declare class SolanaChain extends Chain<ChainAssetData> {
+    readonly id: number;
+    readonly rpcUrls: ChainRpcs;
+    readonly wormhole?: Wormhole;
+    constructor({ id, rpcUrls, wormhole, ...others }: SolanaChainParams);
+    get connection(): Connection;
+    getType(): ChainType;
+    getCurrency(): Promise<ChainCurrency>;
+}

package/build/types/chain/SuiChain.d.ts

@@ -0,0 +1,15 @@
+import { SuiClient } from '@mysten/sui/client';
+import { Chain, ChainAssetData, ChainCurrency, ChainParams, ChainType } from './Chain';
+import { Wormhole, WormholeDef } from '../bridge';
+export interface SuiChainParams extends ChainParams<ChainAssetData> {
+    id: string;
+    wormhole?: WormholeDef;
+}
+export declare class SuiChain extends Chain<ChainAssetData> {
+    readonly id: string;
+    readonly wormhole?: Wormhole;
+    constructor({ id, wormhole, ...others }: SuiChainParams);
+    get client(): SuiClient;
+    getType(): ChainType;
+    getCurrency(): Promise<ChainCurrency>;
+}

package/build/types/chain/dex/factory.d.ts

@@ -0,0 +1,9 @@
+import { Dex } from './types';
+export declare class DexFactory {
+    private static _instance;
+    private _dex;
+    constructor();
+    static getInstance(): DexFactory;
+    register(dex: Dex): void;
+    get(key: string): Dex | undefined;
+}

package/build/types/chain/dex/index.d.ts

@@ -0,0 +1,2 @@
+export * from './factory';
+export * from './types';

package/build/types/chain/dex/types.d.ts

@@ -0,0 +1,11 @@
+import { Asset, AssetAmount } from '../../asset';
+import { AnyChain } from '../types';
+export type SwapQuote = {
+    amount: bigint;
+    route: {};
+};
+export interface Dex {
+    chain: AnyChain;
+    getQuote(assetIn: Asset, assetOut: Asset, amountOut: AssetAmount, fallbackPrice?: boolean): Promise<SwapQuote>;
+    getCalldata(account: string, assetIn: Asset, assetOut: Asset, amountOut: AssetAmount, slippage?: number): Promise<string>;
+}

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

@@ -0,0 +1,8 @@
+export * from './Chain';
+export * from './Parachain';
+export * from './EvmParachain';
+export * from './EvmChain';
+export * from './SolanaChain';
+export * from './SuiChain';
+export * from './dex';
+export * from './types';

package/build/types/chain/types.d.ts

@@ -0,0 +1,8 @@
+import { Parachain } from './Parachain';
+import { EvmParachain } from './EvmParachain';
+import { EvmChain } from './EvmChain';
+import { SolanaChain } from './SolanaChain';
+import { SuiChain } from './SuiChain';
+export type AnyChain = Parachain | EvmParachain | EvmChain | SolanaChain | SuiChain;
+export type AnyParachain = Parachain | EvmParachain;
+export type AnyEvmChain = EvmChain | EvmParachain;

package/build/types/config/ConfigBuilder.d.ts

@@ -0,0 +1,19 @@
+import { Asset } from '../asset';
+import { AnyChain, ChainEcosystem } from '../chain';
+import { TransferConfigs } from './types';
+import { ConfigService } from './ConfigService';
+export declare function ConfigBuilder(service: ConfigService): {
+    assets: (ecosystem?: ChainEcosystem) => {
+        assets: Asset[];
+        asset: (keyOrAsset: string | Asset) => {
+            sourceChains: AnyChain[];
+            source: (keyOrChain: string | AnyChain) => {
+                destinationChains: AnyChain[];
+                destination: (keyOrChain: string | AnyChain) => {
+                    routes: import("./definition").AssetRoute[];
+                    build: (assetOnDest?: string | Asset) => TransferConfigs;
+                };
+            };
+        };
+    };
+};

package/build/types/config/ConfigService.d.ts

@@ -0,0 +1,25 @@
+import { Asset } from '../asset';
+import { AnyChain, ChainEcosystem } from '../chain';
+import { AssetRoute, ChainRoutes } from './definition';
+export interface ConfigServiceOptions {
+    assets: Map<string, Asset>;
+    chains: Map<string, AnyChain>;
+    routes: Map<string, ChainRoutes>;
+}
+export declare class ConfigService {
+    readonly assets: Map<string, Asset>;
+    readonly chains: Map<string, AnyChain>;
+    readonly routes: Map<string, ChainRoutes>;
+    constructor({ assets, chains, routes }: ConfigServiceOptions);
+    getEcosystemAssets(ecosystem?: ChainEcosystem): Asset[];
+    getAsset(keyOrAsset: string | Asset): Asset;
+    getChain(keyOrChain: string | AnyChain): AnyChain;
+    getChainRoutes(keyOrChain: string | AnyChain): ChainRoutes;
+    getSourceChains(asset: Asset, ecosystem: ChainEcosystem | undefined): AnyChain[];
+    getDestinationChains(asset: Asset, source: AnyChain): AnyChain[];
+    getAssetRoutes(asset: Asset, source: AnyChain, destination: AnyChain): AssetRoute[];
+    updateAsset(asset: Asset): void;
+    updateChain(chain: AnyChain): void;
+    updateRoutes(routes: ChainRoutes): void;
+    updateChainRoute(chain: AnyChain, route: AssetRoute): void;
+}

package/build/types/config/definition/AssetRoute.d.ts

@@ -0,0 +1,50 @@
+import { Asset } from '../../asset';
+import { AnyChain, Parachain } from '../../chain';
+import { BalanceConfigBuilder } from './balance';
+import { ContractConfigBuilder } from './contract';
+import { ExtrinsicConfigBuilder } from './extrinsic';
+import { FeeConfig, DestinationFeeConfig, TransactFeeConfig } from './fee';
+import { MinConfigBuilder } from './min';
+import { ProgramConfigBuilder } from './program';
+import { MoveConfigBuilder } from './move';
+export interface SourceConfig {
+    asset: Asset;
+    balance: BalanceConfigBuilder;
+    destinationFee: {
+        asset?: Asset;
+        balance: BalanceConfigBuilder;
+    };
+    fee?: FeeConfig;
+    min?: MinConfigBuilder;
+}
+export interface DestinationConfig {
+    chain: AnyChain;
+    asset: Asset;
+    fee: DestinationFeeConfig;
+}
+export interface TransactConfig {
+    chain: Parachain;
+    fee: TransactFeeConfig;
+    extrinsic: ExtrinsicConfigBuilder;
+}
+export interface AssetRouteParams {
+    source: SourceConfig;
+    destination: DestinationConfig;
+    contract?: ContractConfigBuilder;
+    extrinsic?: ExtrinsicConfigBuilder;
+    move?: MoveConfigBuilder;
+    program?: ProgramConfigBuilder;
+    transact?: TransactConfig;
+    tags?: string[];
+}
+export declare class AssetRoute {
+    readonly source: SourceConfig;
+    readonly destination: DestinationConfig;
+    readonly contract?: ContractConfigBuilder;
+    readonly extrinsic?: ExtrinsicConfigBuilder;
+    readonly move?: MoveConfigBuilder;
+    readonly program?: ProgramConfigBuilder;
+    readonly transact?: TransactConfig;
+    readonly tags?: string[];
+    constructor({ source, destination, contract, extrinsic, move, program, transact, tags, }: AssetRouteParams);
+}

package/build/types/config/definition/ChainRoutes.d.ts

@@ -0,0 +1,17 @@
+import { Asset } from '../../asset';
+import { AnyChain } from '../../chain';
+import { AssetRoute } from './AssetRoute';
+export interface ChainRoutesParams {
+    chain: AnyChain;
+    routes: AssetRoute[];
+}
+export declare class ChainRoutes {
+    readonly routes: Map<string, AssetRoute>;
+    readonly chain: AnyChain;
+    constructor({ chain, routes }: ChainRoutesParams);
+    getRoutes(): AssetRoute[];
+    getUniqueRoutes(): AssetRoute[];
+    getAssetRoutes(asset: Asset): AssetRoute[];
+    getAssetDestinations(asset: Asset): AnyChain[];
+    getAssetDestinationRoutes(asset: Asset, destination: AnyChain): AssetRoute[];
+}

package/build/types/config/definition/balance/BalanceConfigBuilder.d.ts

@@ -0,0 +1,12 @@
+import { SolanaQueryConfig, SubstrateQueryConfig } from '../base';
+import { ContractConfig } from '../contract';
+import { Asset } from '../../../asset';
+import { AnyChain } from '../../../chain';
+export interface BalanceConfigBuilderParams {
+    address: string;
+    asset: Asset;
+    chain: AnyChain;
+}
+export interface BalanceConfigBuilder {
+    build: (params: BalanceConfigBuilderParams) => ContractConfig | SubstrateQueryConfig | SolanaQueryConfig;
+}

package/build/types/config/definition/balance/index.d.ts

@@ -0,0 +1 @@
+export * from './BalanceConfigBuilder';

package/build/types/config/definition/base/BaseConfig.d.ts

@@ -0,0 +1,13 @@
+import { CallType } from './types';
+export interface BaseConfigParams {
+    module: string;
+    func: string;
+    type: CallType;
+}
+export declare class BaseConfig {
+    readonly module: string;
+    readonly func: string;
+    readonly type: CallType;
+    constructor({ module, func, type }: BaseConfigParams);
+    toString(): string;
+}

package/build/types/config/definition/base/SolanaQueryConfig.d.ts

@@ -0,0 +1,10 @@
+import { BaseConfig, BaseConfigParams } from './BaseConfig';
+export interface SolanaQueryConfigParams extends Omit<BaseConfigParams, 'type'> {
+    address: string;
+    token?: string;
+}
+export declare class SolanaQueryConfig extends BaseConfig {
+    readonly address: string;
+    readonly token?: string;
+    constructor({ address, token, ...other }: SolanaQueryConfigParams);
+}

package/build/types/config/definition/base/SubstrateQueryConfig.d.ts

@@ -0,0 +1,10 @@
+import { BaseConfig, BaseConfigParams } from './BaseConfig';
+export interface SubstrateQueryConfigParams extends Omit<BaseConfigParams, 'type'> {
+    args?: any[];
+    transform: (data: any) => Promise<bigint>;
+}
+export declare class SubstrateQueryConfig extends BaseConfig {
+    readonly args: any[];
+    readonly transform: (data: any) => Promise<bigint>;
+    constructor({ args, transform, ...other }: SubstrateQueryConfigParams);
+}

package/build/types/config/definition/base/SuiQueryConfig.d.ts

@@ -0,0 +1,9 @@
+import { BaseConfig, BaseConfigParams } from './BaseConfig';
+export interface SuiQueryConfigParams extends Omit<BaseConfigParams, 'type'> {
+    address: string;
+}
+export declare class SuiQueryConfig extends BaseConfig {
+    readonly address: string;
+    readonly token?: string;
+    constructor({ address, ...other }: SuiQueryConfigParams);
+}

package/build/types/config/definition/base/index.d.ts

@@ -0,0 +1,5 @@
+export * from './BaseConfig';
+export * from './SolanaQueryConfig';
+export * from './SubstrateQueryConfig';
+export * from './SuiQueryConfig';
+export * from './types';

package/build/types/config/definition/base/types.d.ts

@@ -0,0 +1,6 @@
+export declare enum CallType {
+    Evm = "Evm",
+    Substrate = "Substrate",
+    Solana = "Solana",
+    Sui = "Sui"
+}

package/build/types/config/definition/contract/ContractConfig.d.ts

@@ -0,0 +1,16 @@
+import { type Abi as TAbi } from 'viem';
+import { BaseConfig, BaseConfigParams } from '../base';
+export interface ContractConfigParams extends Omit<BaseConfigParams, 'type'> {
+    abi: TAbi;
+    args: any[];
+    address: string;
+    value?: bigint;
+}
+export declare class ContractConfig extends BaseConfig {
+    readonly abi: TAbi;
+    readonly address: string;
+    readonly args: any[];
+    readonly value?: bigint;
+    constructor({ abi, address, args, value, ...other }: ContractConfigParams);
+    encodeFunctionData(): `0x${string}`;
+}

package/build/types/config/definition/contract/ContractConfigBuilder.d.ts

@@ -0,0 +1,7 @@
+import { TransferCtx } from '../../types';
+import { ContractConfig } from './ContractConfig';
+export interface ContractConfigBuilderParams extends TransferCtx {
+}
+export interface ContractConfigBuilder {
+    build: (params: ContractConfigBuilderParams) => Promise<ContractConfig>;
+}

package/build/types/config/definition/contract/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ContractConfig';
+export * from './ContractConfigBuilder';

package/build/types/config/definition/extrinsic/ExtrinsicConfig.d.ts

@@ -0,0 +1,9 @@
+import { BaseConfig, BaseConfigParams } from '../base';
+export type TxData = Record<string, any> | undefined;
+export interface ExtrinsicConfigParams extends Omit<BaseConfigParams, 'type'> {
+    getArgs: (func?: any) => TxData;
+}
+export declare class ExtrinsicConfig extends BaseConfig {
+    getArgs: (func?: any) => TxData;
+    constructor({ getArgs, ...other }: ExtrinsicConfigParams);
+}

package/build/types/config/definition/extrinsic/ExtrinsicConfigBuilder.d.ts

@@ -0,0 +1,22 @@
+import { AssetAmount } from '../../../asset';
+import { AnyParachain } from '../../../chain';
+import { TransferCtx } from '../../types';
+import { ExtrinsicConfig } from './ExtrinsicConfig';
+export interface TxWeight {
+    proofSize: string;
+    refTime: number;
+}
+export interface TransactCtx {
+    chain: AnyParachain;
+    fee: AssetAmount;
+    feeBalance: AssetAmount;
+    call: `0x${string}`;
+    weight: TxWeight;
+}
+export interface ExtrinsicConfigBuilderParams extends TransferCtx {
+    messageId?: string;
+    transact?: TransactCtx;
+}
+export interface ExtrinsicConfigBuilder {
+    build: (params: ExtrinsicConfigBuilderParams) => ExtrinsicConfig;
+}

package/build/types/config/definition/extrinsic/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ExtrinsicConfig';
+export * from './ExtrinsicConfigBuilder';

package/build/types/config/definition/fee/FeeAmountConfigBuilder.d.ts

@@ -0,0 +1,17 @@
+import { Asset } from '../../../asset';
+import { AnyChain } from '../../../chain';
+export type FeeAmount = {
+    amount: bigint;
+    breakdown: {
+        [key: string]: bigint;
+    };
+};
+export interface FeeAmountConfigParams {
+    feeAsset: Asset;
+    transferAsset: Asset;
+    source: AnyChain;
+    destination: AnyChain;
+}
+export interface FeeAmountConfigBuilder {
+    build: (params: FeeAmountConfigParams) => Promise<FeeAmount>;
+}

package/build/types/config/definition/fee/FeeAssetConfigBuilder.d.ts

@@ -0,0 +1,9 @@
+import { Asset } from '../../../asset';
+import { Parachain } from '../../../chain';
+export interface FeeAssetConfigParams {
+    address: string;
+    chain: Parachain;
+}
+export interface FeeAssetConfigBuilder {
+    build: (params: FeeAssetConfigParams) => Promise<Asset>;
+}

package/build/types/config/definition/fee/FeeConfig.d.ts

@@ -0,0 +1,20 @@
+import { BalanceConfigBuilder } from '../balance';
+import { Asset } from '../../../asset';
+import { FeeAssetConfigBuilder } from './FeeAssetConfigBuilder';
+import { FeeAmountConfigBuilder } from './FeeAmountConfigBuilder';
+export interface FeeConfig {
+    asset: Asset | FeeAssetConfigBuilder;
+    balance: BalanceConfigBuilder;
+    extra?: number;
+    swap?: boolean;
+}
+export interface DestinationFeeConfig {
+    amount: number | FeeAmountConfigBuilder;
+    asset: Asset;
+    balance?: BalanceConfigBuilder;
+}
+export interface TransactFeeConfig {
+    amount: number;
+    asset: Asset;
+    balance: BalanceConfigBuilder;
+}

package/build/types/config/definition/fee/index.d.ts

@@ -0,0 +1,3 @@
+export * from './FeeConfig';
+export * from './FeeAmountConfigBuilder';
+export * from './FeeAssetConfigBuilder';

package/build/types/config/definition/index.d.ts

@@ -0,0 +1,10 @@
+export * from './AssetRoute';
+export * from './ChainRoutes';
+export * from './balance';
+export * from './base';
+export * from './contract';
+export * from './extrinsic';
+export * from './move';
+export * from './program';
+export * from './fee';
+export * from './min';

package/build/types/config/definition/min/MinConfigBuilder.d.ts

@@ -0,0 +1,8 @@
+import { SubstrateQueryConfig } from '../base';
+import { ChainAssetId } from '../../../chain';
+export interface MinConfigBuilder {
+    build: (params: MinConfigBuilderParams) => SubstrateQueryConfig;
+}
+export interface MinConfigBuilderParams {
+    asset: ChainAssetId;
+}

package/build/types/config/definition/min/index.d.ts

@@ -0,0 +1 @@
+export * from './MinConfigBuilder';

package/build/types/config/definition/move/MoveConfig.d.ts

@@ -0,0 +1,9 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { BaseConfig, BaseConfigParams } from '../base';
+export interface MoveConfigParams extends Omit<BaseConfigParams, 'type'> {
+    transaction: Transaction;
+}
+export declare class MoveConfig extends BaseConfig {
+    readonly transaction: Transaction;
+    constructor({ transaction, ...other }: MoveConfigParams);
+}

package/build/types/config/definition/move/MoveConfigBuilder.d.ts

@@ -0,0 +1,7 @@
+import { TransferCtx } from '../../types';
+import { MoveConfig } from './MoveConfig';
+export interface MoveConfigBuilderParams extends TransferCtx {
+}
+export interface MoveConfigBuilder {
+    build: (params: MoveConfigBuilderParams) => Promise<MoveConfig>;
+}

package/build/types/config/definition/move/index.d.ts

@@ -0,0 +1,2 @@
+export * from './MoveConfig';
+export * from './MoveConfigBuilder';

package/build/types/config/definition/program/ProgramConfig.d.ts

@@ -0,0 +1,11 @@
+import { Keypair, TransactionInstruction } from '@solana/web3.js';
+import { BaseConfig, BaseConfigParams } from '../base';
+export interface ProgramConfigParams extends Omit<BaseConfigParams, 'type'> {
+    instructions: TransactionInstruction[];
+    signers: Keypair[];
+}
+export declare class ProgramConfig extends BaseConfig {
+    readonly instructions: TransactionInstruction[];
+    readonly signers: Keypair[];
+    constructor({ instructions, signers, ...other }: ProgramConfigParams);
+}

package/build/types/config/definition/program/ProgramConfigBuilder.d.ts

@@ -0,0 +1,7 @@
+import { TransferCtx } from '../../types';
+import { ProgramConfig } from './ProgramConfig';
+export interface ProgramConfigBuilderParams extends TransferCtx {
+}
+export interface ProgramConfigBuilder {
+    build: (params: ProgramConfigBuilderParams) => Promise<ProgramConfig>;
+}

package/build/types/config/definition/program/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ProgramConfig';
+export * from './ProgramConfigBuilder';

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

@@ -0,0 +1,5 @@
+export * from './definition';
+export * from './types';
+export * from './validation';
+export { ConfigBuilder } from './ConfigBuilder';
+export { ConfigService } from './ConfigService';

package/build/types/config/types.d.ts

@@ -0,0 +1,42 @@
+import { Asset, AssetAmount } from '../asset';
+import { AnyChain } from '../chain';
+import { AssetRoute, TransactCtx } from './definition';
+export interface SwapCtx {
+    aIn: AssetAmount;
+    aOut: AssetAmount;
+    enabled: boolean;
+    route: any;
+}
+export interface TransferCtx {
+    address: string;
+    amount: bigint;
+    asset: Asset;
+    sender: string;
+    source: {
+        balance: AssetAmount;
+        chain: AnyChain;
+        destinationFee: AssetAmount;
+        destinationFeeBalance: AssetAmount;
+        destinationFeeSwap?: SwapCtx;
+        fee: AssetAmount;
+        feeBalance: AssetAmount;
+        feeSwap?: SwapCtx;
+    };
+    destination: {
+        balance: AssetAmount;
+        chain: AnyChain;
+        fee: AssetAmount;
+        feeBreakdown: {
+            [key: string]: bigint;
+        };
+    };
+    transact?: TransactCtx;
+}
+export interface TransferConfig {
+    chain: AnyChain;
+    route: AssetRoute;
+}
+export interface TransferConfigs {
+    origin: TransferConfig;
+    reverse: TransferConfig;
+}

package/build/types/config/validation.d.ts

@@ -0,0 +1,23 @@
+import { AnyChain } from '../chain';
+import { TransferCtx } from './types';
+export interface TransferValidationReport {
+    [key: string]: any;
+}
+export declare class TransferValidationError extends Error {
+    readonly report: TransferValidationReport;
+    constructor(message: string, report: TransferValidationReport);
+}
+export type TransferValidationConstraint = (chain: AnyChain) => boolean;
+export declare abstract class TransferValidation {
+    readonly sourceConstraint: TransferValidationConstraint;
+    readonly destinationConstraint: TransferValidationConstraint;
+    constructor(sourceConstraint: TransferValidationConstraint, destinationConstraint: TransferValidationConstraint);
+    private ruleFor;
+    abstract validate(ctx: TransferCtx): void;
+    check(ctx: TransferCtx): void;
+}
+export declare class TransferValidator {
+    private criterias;
+    constructor(...criterias: TransferValidation[]);
+    validate(ctx: TransferCtx): Promise<TransferValidationReport[]>;
+}

package/build/types/evm/Erc20Client.d.ts

@@ -0,0 +1,13 @@
+import { EvmClient } from './EvmClient';
+export declare class Erc20Client {
+    readonly client: EvmClient;
+    readonly address: string;
+    constructor(client: EvmClient, address: string);
+    private validateClient;
+    private validateContract;
+    private validateContractAddress;
+    balanceOf(account: string): Promise<bigint>;
+    decimals(): Promise<number>;
+    allowance(owner: string, spender: string): Promise<bigint>;
+    approve(spender: string, amount: bigint): string;
+}