@galacticcouncil/xc-sdk 0.1.0

package/build/types/platforms/evm/balance/Native.d.ts

@@ -0,0 +1,5 @@
+import { EvmBalance } from './EvmBalance';
+export declare class Native extends EvmBalance {
+    getBalance(): Promise<bigint>;
+    getDecimals(): Promise<number>;
+}

package/build/types/platforms/evm/balance/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EvmBalance';
+export * from './EvmBalanceFactory';

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

@@ -0,0 +1,3 @@
+export * from './EvmClaim';
+export * from './EvmPlatform';
+export * from './types';

package/build/types/platforms/evm/transfer/EvmTransfer.d.ts

@@ -0,0 +1,23 @@
+import { ContractConfig, EvmClient } from '@galacticcouncil/xc-core';
+import { Abi, BaseError, Log } from 'viem';
+import { EvmEventLog } from '../types';
+type SimulateCallResult = {
+    error: BaseError | undefined;
+    logs: Log[] | undefined;
+};
+export declare class EvmTransfer {
+    protected readonly client: EvmClient;
+    protected readonly config: ContractConfig;
+    constructor(client: EvmClient, config: ContractConfig);
+    private validateClient;
+    get abi(): Abi;
+    get asset(): string;
+    get calldata(): string;
+    estimateGas(account: string): Promise<bigint>;
+    estimateFee(account: string, balance: bigint): Promise<bigint>;
+    getGasPrice(): Promise<bigint>;
+    getNonce(account: string): Promise<number>;
+    simulateCall(account: string): Promise<SimulateCallResult>;
+    decodeEvents(logs: Log[] | undefined): EvmEventLog[];
+}
+export {};

package/build/types/platforms/evm/transfer/EvmTransferFactory.d.ts

@@ -0,0 +1,5 @@
+import { ContractConfig, EvmClient } from '@galacticcouncil/xc-core';
+import { EvmTransfer } from './EvmTransfer';
+export declare class EvmTransferFactory {
+    static get(client: EvmClient, config: ContractConfig): EvmTransfer;
+}

package/build/types/platforms/evm/transfer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EvmTransfer';
+export * from './EvmTransferFactory';

package/build/types/platforms/evm/transfer/utils.d.ts

@@ -0,0 +1,3 @@
+import { ContractConfig } from '@galacticcouncil/xc-core';
+export declare function isNativeEthBridge(config: ContractConfig): boolean;
+export declare function isPrecompile(config: ContractConfig): boolean;

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

@@ -0,0 +1,19 @@
+import { Call, DryRunResult } from '../types';
+export interface EvmCall extends Call {
+    /** Solidity JSON string ABI. */
+    abi?: string;
+    /** Spending CAP */
+    allowance?: bigint;
+    /** The address the transaction is directed to. */
+    to: `0x${string}`;
+    /** Value sent with this transaction. */
+    value?: bigint;
+}
+export interface EvmEventLog {
+    eventName: string;
+    args: any[] | undefined;
+}
+export interface EvmDryRunResult extends DryRunResult {
+    error: string | undefined;
+    events: EvmEventLog[] | undefined;
+}

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

@@ -0,0 +1,6 @@
+export { PlatformAdapter } from './adapter';
+export * from './evm';
+export * from './solana';
+export * from './substrate';
+export * from './sui';
+export * from './types';

package/build/types/platforms/solana/SolanaClaim.d.ts

@@ -0,0 +1,9 @@
+import { SolanaChain } from '@galacticcouncil/xc-core';
+import { SolanaCall } from './types';
+export declare class SolanaClaim {
+    #private;
+    constructor(chain: SolanaChain);
+    redeem(from: string, vaaRaw: string): Promise<SolanaCall[]>;
+    private derivePostedVaaKey;
+    private getV0Message;
+}

package/build/types/platforms/solana/SolanaLilJit.d.ts

@@ -0,0 +1,54 @@
+import { SolanaChain } from '@galacticcouncil/xc-core';
+type JitoBundleSimulationResponse = {
+    context: {
+        apiVersion: string;
+        slot: number;
+    };
+    value: {
+        summary: 'succeeded' | {
+            failed: {
+                error: {
+                    TransactionFailure: [number[], string];
+                };
+                tx_signature: string;
+            };
+        };
+        transactionResults: Array<{
+            err: null | unknown;
+            logs: string[];
+            postExecutionAccounts: null | unknown;
+            preExecutionAccounts: null | unknown;
+            returnData: null | unknown;
+            unitsConsumed: number;
+        }>;
+    };
+};
+type JitoBundleStatus = {
+    context: {
+        apiVersion: string;
+        slot: number;
+    };
+    value: Array<{
+        bundle_id: string;
+        landed_slot: number;
+        status: string;
+    }>;
+};
+export declare class SolanaLilJit {
+    #private;
+    constructor(chain: SolanaChain);
+    /**
+     * Returns bundle id
+     *
+     * @see https://explorer.jito.wtf/bundle/${bundle_id}
+     *
+     * @param encoded base 64 encoded tx
+     * @returns bundle id
+     */
+    sendBundle(encoded: string[]): Promise<string>;
+    simulateBundle(encoded: string[]): Promise<JitoBundleSimulationResponse>;
+    getInflightBundleStatuses(bundleIds: string[]): Promise<JitoBundleStatus>;
+    getRegion(): Promise<string[]>;
+    getTipAccount(): Promise<string[]>;
+}
+export {};

package/build/types/platforms/solana/SolanaPlatform.d.ts

@@ -0,0 +1,12 @@
+import { Asset, AssetAmount, ProgramConfig, SolanaChain, SolanaQueryConfig } from '@galacticcouncil/xc-core';
+import { Observable } from 'rxjs';
+import { SolanaCall } from './types';
+import { Platform } from '../types';
+export declare class SolanaPlatform implements Platform<ProgramConfig, SolanaQueryConfig> {
+    #private;
+    constructor(chain: SolanaChain);
+    buildCall(account: string, _amount: bigint, _feeBalance: AssetAmount, config: ProgramConfig): Promise<SolanaCall>;
+    estimateFee(account: string, amount: bigint, feeBalance: AssetAmount, config: ProgramConfig): Promise<AssetAmount>;
+    getBalance(asset: Asset, config: SolanaQueryConfig): Promise<AssetAmount>;
+    subscribeBalance(asset: Asset, config: SolanaQueryConfig): Promise<Observable<AssetAmount>>;
+}

package/build/types/platforms/solana/balance/Native.d.ts

@@ -0,0 +1,5 @@
+import { SolanaBalance } from './SolanaBalance';
+export declare class Native extends SolanaBalance {
+    getBalance(): Promise<bigint>;
+    getDecimals(): Promise<number>;
+}

package/build/types/platforms/solana/balance/SolanaBalance.d.ts

@@ -0,0 +1,11 @@
+import { SolanaQueryConfig } from '@galacticcouncil/xc-core';
+import { Connection } from '@solana/web3.js';
+export declare abstract class SolanaBalance {
+    readonly connection: Connection;
+    readonly config: SolanaQueryConfig;
+    constructor(connection: Connection, config: SolanaQueryConfig);
+    private validateConnection;
+    private validateConfig;
+    abstract getBalance(): Promise<bigint>;
+    abstract getDecimals(): Promise<number>;
+}

package/build/types/platforms/solana/balance/SolanaBalanceFactory.d.ts

@@ -0,0 +1,6 @@
+import { SolanaQueryConfig } from '@galacticcouncil/xc-core';
+import { Connection } from '@solana/web3.js';
+import { SolanaBalance } from './SolanaBalance';
+export declare class SolanaBalanceFactory {
+    static get(connection: Connection, config: SolanaQueryConfig): SolanaBalance;
+}

package/build/types/platforms/solana/balance/Token.d.ts

@@ -0,0 +1,9 @@
+import { SolanaQueryConfig } from '@galacticcouncil/xc-core';
+import { Connection } from '@solana/web3.js';
+import { SolanaBalance } from './SolanaBalance';
+export declare class Token extends SolanaBalance {
+    constructor(connection: Connection, config: SolanaQueryConfig);
+    getBalance(): Promise<bigint>;
+    getDecimals(): Promise<number>;
+    private validateToken;
+}

package/build/types/platforms/solana/balance/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SolanaBalance';
+export * from './SolanaBalanceFactory';

package/build/types/platforms/solana/index.d.ts

@@ -0,0 +1,5 @@
+export * from './SolanaPlatform';
+export * from './SolanaClaim';
+export * from './SolanaLilJit';
+export * from './types';
+export * from './utils';

package/build/types/platforms/solana/transfer/SolanaTransfer.d.ts

@@ -0,0 +1,33 @@
+import { ProgramConfig } from '@galacticcouncil/xc-core';
+import { Connection, MessageV0, SimulatedTransactionResponse } from '@solana/web3.js';
+export declare class SolanaTransfer {
+    readonly connection: Connection;
+    readonly config: ProgramConfig;
+    constructor(connection: Connection, config: ProgramConfig);
+    private validateConnection;
+    getPriorityMessage(account: string): Promise<MessageV0>;
+    estimateFee(account: string, balance: bigint): Promise<bigint>;
+    private getV0Message;
+    private createPriorityFeeInstructions;
+    simulateTransaction(account: string, message: MessageV0): Promise<SimulatedTransactionResponse>;
+    /**
+     * Determine compute budget from simulated transaction
+     *
+     * @param transaction - versioned transaction
+     * @returns Compute budget to 120% of the units used in the
+     * simulated transaction or default
+     */
+    determineComputeBudget(message: MessageV0): Promise<number>;
+    /**
+     * Determine the priority fee to use for a transaction
+     *
+     * @param transaction - the transaction to determine the priority fee for
+     * @param percentile - the percentile of recent fees to use
+     * @param multiple - the multiple to apply to the percentile fee
+     * @param minPriorityFee - the minimum priority fee to use
+     * @param maxPriorityFee - the maximum priority fee to use
+     * @returns the priority fee to use according to the recent transactions and the given parameters
+     */
+    determinePriorityFee(message: MessageV0, percentile?: number, multiple?: number, minPriorityFee?: number, maxPriorityFee?: number): Promise<number>;
+    private getTxAccounts;
+}

package/build/types/platforms/solana/transfer/SolanaTransferFactory.d.ts

@@ -0,0 +1,6 @@
+import { ProgramConfig } from '@galacticcouncil/xc-core';
+import { Connection } from '@solana/web3.js';
+import { SolanaTransfer } from './SolanaTransfer';
+export declare class SolanaTransferFactory {
+    static get(connection: Connection, config: ProgramConfig): SolanaTransfer;
+}

package/build/types/platforms/solana/transfer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SolanaTransfer';
+export * from './SolanaTransferFactory';

package/build/types/platforms/solana/types.d.ts

@@ -0,0 +1,15 @@
+import { Keypair, TransactionError } from '@solana/web3.js';
+import { Call, DryRunResult } from '../types';
+export interface SolanaCall extends Call {
+    ix: HumanizedIx[];
+    signers: Keypair[];
+}
+export interface HumanizedIx {
+    program: string;
+    data: string;
+    keys: string[];
+}
+export interface SolanaDryRunResult extends DryRunResult {
+    error: TransactionError | null;
+    events: string[] | null;
+}

package/build/types/platforms/solana/utils.d.ts

@@ -0,0 +1,6 @@
+import { MessageV0, TransactionInstruction } from '@solana/web3.js';
+import { HumanizedIx } from './types';
+export declare function ixToHuman(instructions: TransactionInstruction[]): HumanizedIx[];
+export declare function chunkBySize(instructions: TransactionInstruction[], maxBytes?: number): TransactionInstruction[][];
+export declare function serializeV0(mssgV0: MessageV0): string;
+export declare function deserializeV0(mssgV0: string): MessageV0;

package/build/types/platforms/substrate/SubstrateClaim.d.ts

@@ -0,0 +1,9 @@
+import { EvmParachain } from '@galacticcouncil/xc-core';
+import { SubstrateCall } from './types';
+import { EvmCall } from '../evm';
+export declare class SubstrateClaim {
+    #private;
+    constructor(chain: EvmParachain);
+    redeemMrl(from: string, vaaBytes: string): EvmCall;
+    redeemMrlViaXcm(from: string, vaaBytes: string): Promise<SubstrateCall>;
+}

package/build/types/platforms/substrate/SubstrateExec.d.ts

@@ -0,0 +1,11 @@
+import { Asset, AssetAmount } from '@galacticcouncil/xc-core';
+import { SubstrateService } from './SubstrateService';
+import { SubstrateCall } from './types';
+import { Call } from '../types';
+export declare class SubstrateExec {
+    #private;
+    constructor(src: SubstrateService, dst: SubstrateService);
+    remoteExec(srcAccount: string, dstAccount: string, dstCall: SubstrateCall, transfer: (fees: AssetAmount) => Promise<Call>, opts?: {
+        srcFeeAsset?: Asset;
+    }): Promise<SubstrateCall>;
+}

package/build/types/platforms/substrate/SubstratePlatform.d.ts

@@ -0,0 +1,23 @@
+import { AnyParachain, Asset, AssetAmount, ExtrinsicConfig, SubstrateQueryConfig } from '@galacticcouncil/xc-core';
+import { Observable } from 'rxjs';
+import { SubstrateCall } from './types';
+import { Platform } from '../types';
+export declare class SubstratePlatform implements Platform<ExtrinsicConfig, SubstrateQueryConfig> {
+    #private;
+    constructor(chain: AnyParachain);
+    private useSignerFee;
+    buildCall(account: string, _amount: bigint, feeBalance: AssetAmount, config: ExtrinsicConfig): Promise<SubstrateCall>;
+    estimateFee(account: string, _amount: bigint, feeBalance: AssetAmount, config: ExtrinsicConfig): Promise<AssetAmount>;
+    getBalance(asset: Asset, config: SubstrateQueryConfig): Promise<AssetAmount>;
+    subscribeBalance(asset: Asset, config: SubstrateQueryConfig): Promise<Observable<AssetAmount>>;
+    /**
+     * Display native fee in user preferred fee payment asset
+     *
+     * Supported only if on-chain swap enabled (dex support)
+     *
+     * @param fee - native fee
+     * @param feeBalance - user preferred payment asset balance
+     * @returns - fee in user preferred payment asset
+     */
+    private exchangeFee;
+}

package/build/types/platforms/substrate/SubstrateService.d.ts

@@ -0,0 +1,32 @@
+import { AnyParachain, Asset, AssetAmount, ExtrinsicConfig } from '@galacticcouncil/xc-core';
+import { PolkadotClient, Transaction } from 'polkadot-api';
+export declare class SubstrateService {
+    readonly client: PolkadotClient;
+    readonly api: ReturnType<PolkadotClient['getUnsafeApi']>;
+    readonly chain: AnyParachain;
+    private _chainSpec?;
+    private _asset?;
+    private _decimals?;
+    constructor(client: PolkadotClient, chain: AnyParachain);
+    static create(chain: AnyParachain): Promise<SubstrateService>;
+    private getChainSpec;
+    getAsset(): Promise<Asset>;
+    getDecimals(): Promise<number>;
+    getExistentialDeposit(): Promise<AssetAmount>;
+    isDryRunSupported(): boolean;
+    getDecimalsForAsset(asset: Asset): Promise<number>;
+    getExtrinsic(config: ExtrinsicConfig): Transaction<any, any, any, any>;
+    /**
+     * Check if extrinsic is a batch call
+     */
+    private isBatchCall;
+    /**
+     * Build batch call with recursive ExtrinsicConfig processing
+     */
+    private buildBatchCall;
+    buildMessageId(account: string, amount: bigint, asset: string, beneficiary: string): Promise<string>;
+    dryRun(account: string, extrinsic: Transaction<any, any, any, any>): Promise<any>;
+    estimateNetworkFee(account: string, config: ExtrinsicConfig): Promise<bigint>;
+    estimateDeliveryFee(account: string, config: ExtrinsicConfig): Promise<bigint>;
+    private estimateDeliveryFeeWith;
+}

package/build/types/platforms/substrate/index.d.ts

@@ -0,0 +1,5 @@
+export * from './SubstrateClaim';
+export * from './SubstrateExec';
+export * from './SubstratePlatform';
+export * from './SubstrateService';
+export * from './types';

package/build/types/platforms/substrate/types.d.ts

@@ -0,0 +1,12 @@
+import { Asset } from '@galacticcouncil/xc-core';
+import { Call, DryRunResult } from '../types';
+export interface SubstrateCall extends Call {
+    txOptions: {
+        asset: Asset | undefined;
+    } | undefined;
+}
+export interface SubstrateDryRunResult extends DryRunResult {
+    error: string | undefined;
+    events: any | undefined;
+    xcm: any | undefined;
+}

package/build/types/platforms/substrate/utils/amount.d.ts

@@ -0,0 +1,12 @@
+import { Asset, AssetAmountParams } from '@galacticcouncil/xc-core';
+import { SubstrateService } from '../SubstrateService';
+/**
+ * Normalize asset amount if chain uses solely chain decimals
+ * for balance representation of assets.
+ *
+ * @param amount - original chain amount
+ * @param asset - asset
+ * @param substrate - source chain substrate service
+ * @returns normalized asset amount if chain decimals used, otherwise default
+ */
+export declare function normalizeAssetAmount(amount: bigint, asset: Asset, substrate: SubstrateService): Promise<AssetAmountParams>;

package/build/types/platforms/substrate/utils/dryRun.d.ts

@@ -0,0 +1,2 @@
+export declare const getDeliveryFeeFromDryRun: (events: any[]) => bigint;
+export declare const getErrorFromDryRun: (dispatchError: any) => string | undefined;

package/build/types/platforms/substrate/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './amount';
+export * from './dryRun';
+export * from './naming';
+export * from './xcm';

package/build/types/platforms/substrate/utils/naming.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Naming conversion utilities for PAPI unsafe API
+ *
+ * These utilities convert config-style names to PAPI runtime names.
+ * Used when working with unsafe API for generic chain support.
+ */
+/**
+ * Convert string to PascalCase (first letter uppercase)
+ * Used for pallet names and query function names in PAPI
+ * @example
+ * toPascalCase('balances') // 'Balances'
+ * toPascalCase('polkadotXcm') // 'PolkadotXcm'
+ * toPascalCase('multiTransactionPayment') // 'MultiTransactionPayment'
+ */
+export declare function toPascalCase(str: string): string;
+/**
+ * Convert camelCase string to snake_case
+ * Used for extrinsic/function names in PAPI
+ * @example
+ * toSnakeCase('transferAll') // 'transfer_all'
+ * toSnakeCase('batchAll') // 'batch_all'
+ * toSnakeCase('setSufficient') // 'set_sufficient'
+ */
+export declare function toSnakeCase(str: string): string;

package/build/types/platforms/substrate/utils/xcm.d.ts

@@ -0,0 +1,110 @@
+import { AnyParachain, AssetAmount } from '@galacticcouncil/xc-core';
+export declare function buildBeneficiary(dstAccount: string): {
+    parents: number;
+    interior: {
+        X1: {
+            AccountKey20: {
+                key: string;
+            };
+        }[];
+    };
+} | {
+    parents: number;
+    interior: {
+        X1: {
+            AccountId32: {
+                id: string;
+            };
+        }[];
+    };
+};
+export declare function buildXcmDest(dstChain: AnyParachain): {
+    V4: {
+        parents: number;
+        interior: {
+            X1: {
+                Parachain: number;
+            }[];
+        };
+    };
+};
+export declare function buildXcmMessage(dstAccount: string, dstFeeLocation: any, dstFee: AssetAmount, dstRefTime: number, dstProofSize: string, dstCallEncoded: string): {
+    V4: ({
+        WithdrawAsset: {
+            id: any;
+            fun: {
+                Fungible: bigint;
+            };
+        }[];
+        BuyExecution?: undefined;
+        Transact?: undefined;
+        RefundSurplus?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        BuyExecution: {
+            fees: {
+                id: any;
+                fun: {
+                    Fungible: bigint;
+                };
+            };
+            weightLimit: string;
+        };
+        WithdrawAsset?: undefined;
+        Transact?: undefined;
+        RefundSurplus?: undefined;
+        DepositAsset?: undefined;
+    } | {
+        Transact: {
+            originKind: string;
+            requireWeightAtMost: {
+                refTime: number;
+                proofSize: string;
+            };
+            call: {
+                encoded: 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: {
+                        AccountKey20: {
+                            key: string;
+                        };
+                    }[];
+                };
+            } | {
+                parents: number;
+                interior: {
+                    X1: {
+                        AccountId32: {
+                            id: string;
+                        };
+                    }[];
+                };
+            };
+        };
+        WithdrawAsset?: undefined;
+        BuyExecution?: undefined;
+        Transact?: undefined;
+        RefundSurplus?: undefined;
+    })[];
+};

package/build/types/platforms/sui/SuiPlatform.d.ts

@@ -0,0 +1,12 @@
+import { Asset, AssetAmount, MoveConfig, SuiChain, SuiQueryConfig } from '@galacticcouncil/xc-core';
+import { Observable } from 'rxjs';
+import { SuiCall } from './types';
+import { Platform } from '../types';
+export declare class SuiPlatform implements Platform<MoveConfig, SuiQueryConfig> {
+    #private;
+    constructor(chain: SuiChain);
+    buildCall(account: string, _amount: bigint, _feeBalance: AssetAmount, config: MoveConfig): Promise<SuiCall>;
+    estimateFee(account: string, _amount: bigint, feeBalance: AssetAmount, config: MoveConfig): Promise<AssetAmount>;
+    getBalance(asset: Asset, config: SuiQueryConfig): Promise<AssetAmount>;
+    subscribeBalance(asset: Asset, config: SuiQueryConfig): Promise<Observable<AssetAmount>>;
+}

package/build/types/platforms/sui/balance/Native.d.ts

@@ -0,0 +1,5 @@
+import { SuiBalance } from './SuiBalance';
+export declare class Native extends SuiBalance {
+    getBalance(): Promise<bigint>;
+    getDecimals(): Promise<number>;
+}

package/build/types/platforms/sui/balance/SuiBalance.d.ts

@@ -0,0 +1,11 @@
+import { SuiQueryConfig } from '@galacticcouncil/xc-core';
+import { SuiClient } from '@mysten/sui/client';
+export declare abstract class SuiBalance {
+    readonly client: SuiClient;
+    readonly config: SuiQueryConfig;
+    constructor(client: SuiClient, config: SuiQueryConfig);
+    private validateClient;
+    private validateConfig;
+    abstract getBalance(): Promise<bigint>;
+    abstract getDecimals(): Promise<number>;
+}

package/build/types/platforms/sui/balance/SuiBalanceFactory.d.ts

@@ -0,0 +1,6 @@
+import { SuiQueryConfig } from '@galacticcouncil/xc-core';
+import { SuiClient } from '@mysten/sui/client';
+import { SuiBalance } from './SuiBalance';
+export declare class SuiBalanceFactory {
+    static get(client: SuiClient, config: SuiQueryConfig): SuiBalance;
+}

package/build/types/platforms/sui/balance/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SuiBalance';
+export * from './SuiBalanceFactory';

package/build/types/platforms/sui/index.d.ts

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

package/build/types/platforms/sui/types.d.ts

@@ -0,0 +1,4 @@
+import { Call } from '../types';
+export interface SuiCall extends Call {
+    commands: any[];
+}

package/build/types/platforms/sui/utils.d.ts

@@ -0,0 +1,10 @@
+type NumberMode = 'string' | 'number' | 'bigint';
+type Options = {
+    numbers?: NumberMode;
+    decode32As?: 'address' | 'vector<u8>';
+};
+export declare function resolveCommandsTyped(root: {
+    inputs: any[];
+    commands: any[];
+}, opts?: Options): any[];
+export {};

package/build/types/platforms/types.d.ts

@@ -0,0 +1,25 @@
+import { Asset, AssetAmount, BaseConfig, CallType } from '@galacticcouncil/xc-core';
+import { Observable } from 'rxjs';
+export interface Platform<T extends BaseConfig, B extends BaseConfig> {
+    buildCall(account: string, amount: bigint, feeBalance: AssetAmount, config: T): Promise<Call>;
+    estimateFee(account: string, amount: bigint, feeBalance: AssetAmount, config: T): Promise<AssetAmount>;
+    getBalance(asset: Asset, config: B): Promise<AssetAmount>;
+    subscribeBalance(asset: Asset, config: B): Promise<Observable<AssetAmount>>;
+}
+export interface Call {
+    /** Owner of transation. */
+    from: string;
+    /** Hex-encoded call data. */
+    data: string;
+    /** Calltype. */
+    type: CallType;
+    /**
+     * Simulate call execution
+     */
+    dryRun(): Promise<DryRunResult | undefined>;
+}
+export interface DryRunResult {
+    call: string;
+    error: any | undefined;
+    events: any | undefined;
+}