@bnb-chain/canonical-bridge-sdk/dist/core/index.d.ts

canonical bridge sdk

import { LayerZero } from '../adapters/layerZero';
import { CBridge } from '../adapters/cBridge';
import { IBaseBridgeConfig, IBridgeAddress, IBridgeEndpointId, IApproveTokenInput, IGetAllowanceInput, IGetTokenBalanceInput } from './types';
import { DeBridge, IDeBridgeConfig } from '../adapters/deBridge';
import { Stargate } from '../adapters/stargate';
import { Hash, PublicClient, WalletClient } from 'viem';
import { Meson } from '../adapters/meson';
import { IGetMesonEstimateFeeInput } from '../adapters/meson/types';
import { BridgeType, IBridgeToken } from '../shared/types';
import { IDeBridgeEstimatedFeesInput } from '../adapters/deBridge/types';
import { ICBridgePeggedPairConfig } from '../adapters/cBridge/types';
import { Mayan } from '../adapters/mayan';
import { ILayerZeroQuotaInput, IMayanQuotaInput } from '../adapters/mayan/types';
import { WalletContextState } from '@solana/wallet-adapter-react';
import { Connection } from '@solana/web3.js';

export * from './types';
export interface CanonicalBridgeSDKOptions<T extends IBaseBridgeConfig> {
    bridgeConfigs: T[];
}
export declare class CanonicalBridgeSDK {
    cBridge: CBridge;
    deBridge: DeBridge;
    stargate: Stargate;
    layerZero: LayerZero;
    meson: Meson;
    mayan: Mayan;
    private options;
    constructor(options: CanonicalBridgeSDKOptions<IBaseBridgeConfig | IDeBridgeConfig>);
    /**
     * Get sdk options
     * @returns {CanonicalBridgeSDKOptions<BaseBridgeConfig | DeBridgeConfig>} sdk options
     */
    getSDKOptions(): CanonicalBridgeSDKOptions<IBaseBridgeConfig | IDeBridgeConfig>;
    /**
     * Get supported bridges
     * @returns {BridgeType[]} A string list of supported bridges
     */
    getSupportedBridges(): BridgeType[];
    /**
     * Approve ERC-20 token
     * @param {WalletClient} walletClient Wallet client
     * @param {Address} tokenAddress ERC-20 token address
     * @param {BigInt} amount approve amount
     * @param {Address} address wallet/account address
     * @param {Address} spender spender address
     * @returns {Hash} transaction hash
     */
    approveToken({ walletClient, tokenAddress, amount, address, spender, }: IApproveTokenInput): Promise<Hash>;
    /**
     * Get token allowance
     * @param {PublicClient} publicClient Public client
     * @param {Address} tokenAddress ERC-20 token address
     * @param {Address} owner owner/account address
     * @param {Address} spender spender address
     * @returns {BigInt} token allowance amount
     */
    getTokenAllowance({ publicClient, tokenAddress, owner, spender, }: IGetAllowanceInput): Promise<bigint>;
    /**
     * Get token balance
     * @param {PublicClient} publicClient Public client
     * @param {Address} tokenAddress ERC-20 token address
     * @param {Address} owner owner/account address
     * @returns {BigInt} token balance amount
     */
    getTokenBalance({ publicClient, tokenAddress, owner, }: IGetTokenBalanceInput): Promise<bigint>;
    /**
     * Load bridge fees and return fee information in the following order
     * [deBridge, cBridge, stargate, layerZero, meson, mayan]
     */
    loadBridgeFees({ bridgeType, fromChainId, fromAccount, toAccount, toChainId, sendValue, fromTokenSymbol, publicClient, connection, solanaWallet, endPointId, bridgeAddress, isPegged, slippage, mesonOpts, deBridgeOpts, toToken, mayanOpts, layerZeroOpts, }: {
        bridgeType: BridgeType[];
        fromChainId: number;
        fromAccount: string;
        toAccount: string;
        toChainId: number;
        sendValue: bigint;
        fromTokenSymbol: string;
        publicClient?: PublicClient;
        connection: Connection;
        solanaWallet: WalletContextState;
        endPointId?: IBridgeEndpointId;
        bridgeAddress?: IBridgeAddress;
        isPegged?: boolean;
        slippage?: number;
        mesonOpts?: IGetMesonEstimateFeeInput;
        deBridgeOpts?: IDeBridgeEstimatedFeesInput;
        toToken?: IBridgeToken;
        mayanOpts: IMayanQuotaInput;
        layerZeroOpts: ILayerZeroQuotaInput;
    }): Promise<PromiseSettledResult<any>[]>;
    /**
     * Send token through different bridge mode
     */
    sendToken({ bridgeType, fromChainId, amount, userAddress, tokenAddress, toChainId, bridgeAddress, walletClient, publicClient, slippage, peggedConfig, bridgeEndPointId, debridgeOpts, cBridgeOpts, }: {
        bridgeType: BridgeType;
        fromChainId: number;
        amount: bigint;
        userAddress: `0x${string}`;
        tokenAddress: `0x${string}`;
        toChainId: number;
        bridgeAddress: `0x${string}`;
        walletClient: WalletClient;
        publicClient: PublicClient;
        slippage?: number;
        peggedConfig?: ICBridgePeggedPairConfig;
        deBridgeData?: `0x${string}`;
        bridgeEndPointId?: IBridgeEndpointId;
        debridgeOpts?: {
            data?: `0x${string}`;
        };
        cBridgeOpts?: {
            isPegged?: boolean;
        };
    }): Promise<`0x${string}` | undefined>;
}