@avalabs/bridge-unified 0.0.0-license-20240801163452 → 0.0.0-tmp-lombard-sdk-integration-20251210211743

package/dist/index.d.cts

@@ -1,4 +1,6 @@
 import { Address } from 'viem';
+import { Address as Address$1 } from 'abitype';
+import { z } from 'zod';
 
 type Chain = {
     chainName: string;
@@ -7,28 +9,135 @@ type Chain = {
     utilityAddresses?: {
         multicall: Address;
     };
-    networkToken: Asset;
+    networkToken: NativeAsset;
 };
+declare enum AvalancheChainIds {
+    FUJI = "eip155:43113",
+    MAINNET = "eip155:43114"
+}
+declare enum EthereumChainIds {
+    MAINNET = "eip155:1",
+    SEPOLIA = "eip155:11155111"
+}
+declare enum BitcoinChainIds {
+    MAINNET = "bip122:000000000019d6689c085ae165831e93",
+    TESTNET = "bip122:000000000933ea01ad0ee984209779ba"
+}
+declare const AVALANCHE_FUJI_CHAIN: Chain;
+declare const AVALANCHE_MAINNET_CHAIN: Chain;
+declare const ETHEREUM_SEPOLIA_CHAIN: Chain;
+declare const ETHEREUM_MAINNET_CHAIN: Chain;
+declare const BITCOIN_TESTNET_CHAIN: Chain;
+declare const BITCOIN_MAINNET_CHAIN: Chain;
 
 declare enum Environment {
+    DEV = "dev",
     PROD = "production",
+    STAGING = "staging",
     TEST = "test"
 }
 
-type RequestArguments = {
-    method: string;
-    params?: unknown[] | Record<string | number, unknown>;
-};
-type Provider = {
-    /**
-     * EIP-1193 compatible request method
-     * https://eips.ethereum.org/EIPS/eip-1193#request-1
-     */
-    request: (args: RequestArguments) => Promise<unknown>;
-};
+/**
+ * Custom Bitcoin UTXO interface.
+ */
+
+declare const BitcoinInputUTXO: z.ZodObject<{
+    txHash: z.ZodString;
+    txHex: z.ZodOptional<z.ZodString>;
+    index: z.ZodNumber;
+    value: z.ZodNumber;
+    script: z.ZodString;
+    blockHeight: z.ZodNumber;
+    confirmations: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    txHash: string;
+    value: number;
+    index: number;
+    script: string;
+    blockHeight: number;
+    confirmations: number;
+    txHex?: string | undefined;
+}, {
+    txHash: string;
+    value: number;
+    index: number;
+    script: string;
+    blockHeight: number;
+    confirmations: number;
+    txHex?: string | undefined;
+}>;
+type BitcoinInputUTXO = typeof BitcoinInputUTXO._output;
+declare const BitcoinInputUTXOWithOptionalScript: z.ZodObject<z.objectUtil.extendShape<{
+    txHash: z.ZodString;
+    txHex: z.ZodOptional<z.ZodString>;
+    index: z.ZodNumber;
+    value: z.ZodNumber;
+    script: z.ZodString;
+    blockHeight: z.ZodNumber;
+    confirmations: z.ZodNumber;
+}, {
+    script: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    txHash: string;
+    value: number;
+    index: number;
+    blockHeight: number;
+    confirmations: number;
+    txHex?: string | undefined;
+    script?: string | undefined;
+}, {
+    txHash: string;
+    value: number;
+    index: number;
+    blockHeight: number;
+    confirmations: number;
+    txHex?: string | undefined;
+    script?: string | undefined;
+}>;
+type BitcoinInputUTXOWithOptionalScript = typeof BitcoinInputUTXOWithOptionalScript._output;
+/**
+ * Used for defining outputs when creating a transaction.
+ */
+declare const BitcoinOutputUTXO: z.ZodObject<{
+    address: z.ZodString;
+    value: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    address: string;
+}, {
+    value: number;
+    address: string;
+}>;
+type BitcoinOutputUTXO = typeof BitcoinOutputUTXO._output;
+interface BitcoinTx {
+    hash: string;
+    fees: number;
+    block: number;
+    amount: number;
+    confirmations: number;
+    blockTime: number;
+    addresses: string[];
+    inputs: {
+        txid: string;
+        vout: number;
+        sequence: number;
+        n: number;
+        addresses: string[];
+        isAddress: boolean;
+        value: number;
+    }[];
+    outputs: {
+        addresses: string[];
+        value: number;
+        n: number;
+        spent: boolean;
+        hex: string;
+        isAddress: boolean;
+    }[];
+}
 
 type Hex = `0x${string}`;
-type TransactionRequest = {
+type EvmTransactionRequest = {
     type?: number | null;
     data?: Hex | null;
     from: Hex;
@@ -40,27 +149,58 @@ type TransactionRequest = {
     gasLimit?: bigint | null;
     maxPriorityFeePerGas?: bigint | null;
     maxFeePerGas?: bigint | null;
+    chainId?: string;
+};
+type EvmDispatch = (signedTxHash: Hex) => Promise<Hex>;
+type EvmSign = (data: EvmTransactionRequest, dispatch: EvmDispatch, step: BridgeStepDetails) => Promise<Hex>;
+type EvmSignMessage = (params: {
+    message: string;
+    address: Address$1;
+    chainId: number;
+}, dispatch: EvmDispatch, step: BridgeStepDetails) => Promise<Hex>;
+type EvmSigner = {
+    sign: EvmSign;
+};
+type EvmSignerWithMessage = EvmSigner & {
+    signMessage: EvmSignMessage;
+};
+type BtcTransactionRequest = {
+    inputs: BitcoinInputUTXO[];
+    outputs: BitcoinOutputUTXO[];
+};
+type BtcDispatch = (signedTxHash: string) => Promise<string>;
+type BtcSign = (data: BtcTransactionRequest, dispatch: BtcDispatch, step: BridgeStepDetails) => Promise<string>;
+type BtcSigner = {
+    sign: BtcSign;
 };
-type Dispatch = (signedTxHash: Hex) => Promise<Hex>;
-type Signer = (data: TransactionRequest, dispatch: Dispatch) => Promise<Hex>;
 
 declare enum ErrorCode {
     BRIDGE_NOT_AVAILABLE = 5001,
     INITIALIZATION_FAILED = 5002,
     INVALID_PARAMS = 5003,
     TIMEOUT = 5004,
-    TRANSACTION_REVERTED = 5005
+    TRANSACTION_REVERTED = 5005,
+    NOTARIZATION_FAILED = 5006
 }
 declare enum ErrorReason {
-    UNKNOWN = "UNKNOWN",
+    ASSET_NOT_SUPPORTED = "ASSET_NOT_SUPPORTED",
+    CHAIN_NOT_SUPPORTED = "CHAIN_NOT_SUPPORTED",
     CONFIG_NOT_AVAILABLE = "CONFIG_NOT_AVAILABLE",
-    INVALID_PARAMS = "INVALID_PARAMS",
+    CONFIRMATION_COUNT_UNKNOWN = "CONFIRMATION_COUNT_UNKNOWN",
+    ENVIRONMENT_NOT_SUPPORTED = "ENVIRONMENT_NOT_SUPPORTED",
     IDENTICAL_CHAINS_PROVIDED = "IDENTICAL_CHAINS_PROVIDED",
-    INCORRECT_AMOUNT_PROVIDED = "INCORRECT_AMOUNT_PROVIDED",
     INCORRECT_ADDRESS_PROVIDED = "INCORRECT_ADDRESS_PROVIDED",
-    CHAIN_NOT_SUPPORTED = "CHAIN_NOT_SUPPORTED",
-    ASSET_NOT_SUPPORTED = "ASSET_NOT_SUPPORTED",
-    CONFIRMATION_COUNT_UNKNOWN = "CONFIRMATION_COUNT_UNKNOWN"
+    INCORRECT_AMOUNT_PROVIDED = "INCORRECT_AMOUNT_PROVIDED",
+    INCORRECT_HASH_PROVIDED = "INCORRECT_HASH_PROVIDED",
+    INCORRECT_PROVIDER_PROVIDED = "INCORRECT_PROVIDER_PROVIDED",
+    INCORRECT_SIGNER_PROVIDED = "INCORRECT_SIGNER_PROVIDED",
+    INCORRECT_TXHASH_PROVIDED = "INCORRECT_TXHASH_PROVIDED",
+    INVALID_PARAMS = "INVALID_PARAMS",
+    UNKNOWN = "UNKNOWN",
+    VULNERABLE_TOKEN_APPROVAL_ADDRESS = "VULNERABLE_TOKEN_APPROVAL_ADDRESS",
+    WARDEN_CONFIG_MISMATCH = "WARDEN_CONFIG_MISMATCH",
+    WARDEN_CONFIG_MISSING_NETWORK = "WARDEN_CONFIG_MISSING_NETWORK",
+    ADDRESS_IS_BLOCKED = "ADDRESS_IS_BLOCKED"
 }
 
 type BridgeTransfer = {
@@ -69,8 +209,7 @@ type BridgeTransfer = {
     fromAddress: string;
     toAddress: string;
     amount: bigint;
-    amountDecimals: number;
-    symbol: string;
+    asset: BridgeAsset;
     completedAt?: number;
     errorCode?: ErrorCode;
     bridgeFee: bigint;
@@ -79,64 +218,143 @@ type BridgeTransfer = {
     sourceTxHash: string;
     sourceNetworkFee?: bigint;
     sourceConfirmationCount: number;
-    requiredSourceConfirmationCount: number;
+    sourceRequiredConfirmationCount: number;
     targetChain: Chain;
     targetStartedAt?: number;
     targetTxHash?: string;
     targetNetworkFee?: bigint;
     targetConfirmationCount: number;
-    requiredTargetConfirmationCount: number;
-    startBlockNumber?: bigint;
+    targetRequiredConfirmationCount: number;
+    targetStartBlockNumber?: bigint;
     metadata?: Record<string, unknown>;
 };
 
+interface BitcoinFunctions {
+    getChainHeight: () => Promise<number>;
+    getUTXOs: (address: string, withScripts?: boolean) => Promise<{
+        confirmed: BitcoinInputUTXOWithOptionalScript[];
+        unconfirmed: BitcoinInputUTXOWithOptionalScript[];
+    }>;
+    getTransaction: (hash: string) => Promise<BitcoinTx>;
+    getFeeRates: () => Promise<{
+        low: number;
+        medium: number;
+        high: number;
+    }>;
+    getUtxoBalance: (address: string, withScripts?: boolean) => Promise<{
+        utxos: BitcoinInputUTXOWithOptionalScript[];
+        utxosUnconfirmed: BitcoinInputUTXOWithOptionalScript[];
+    }>;
+    getScriptsForUtxos: (utxos: BitcoinInputUTXOWithOptionalScript[]) => Promise<BitcoinInputUTXO[]>;
+    issueRawTx: (tx: string) => Promise<string>;
+}
+
 declare enum BridgeType {
-    CCTP = "cctp"
+    AVALANCHE_EVM = "avalanche-evm",
+    AVALANCHE_BTC_AVA = "avalanche-btc-ava",
+    AVALANCHE_AVA_BTC = "avalanche-ava-btc",
+    CCTP = "cctp",
+    ICTT_ERC20_ERC20 = "ictt-erc20-erc20",
+    LOMBARD_BTC_TO_BTCB = "lombard-btc-to-btcb",
+    LOMBARD_BTCB_TO_BTC = "lombard-btcb-to-btc"
 }
+declare const BTC_BRIDGE_TYPES: readonly [BridgeType.AVALANCHE_AVA_BTC, BridgeType.AVALANCHE_BTC_AVA, BridgeType.LOMBARD_BTC_TO_BTCB, BridgeType.LOMBARD_BTCB_TO_BTC];
+declare const EVM_BRIDGE_TYPES: readonly [BridgeType.AVALANCHE_EVM, BridgeType.CCTP, BridgeType.ICTT_ERC20_ERC20];
+type ArrayElement<A> = A extends readonly (infer T)[] ? T : never;
+type EvmBridgeInitializer = {
+    type: ArrayElement<typeof EVM_BRIDGE_TYPES>;
+    signer: EvmSigner;
+};
+type AvaToBtcBridgeInitializer = {
+    type: BridgeType.AVALANCHE_AVA_BTC;
+    signer: EvmSigner;
+    bitcoinFunctions: BitcoinFunctions;
+};
+type BtcToAvaBridgeInitializer = {
+    type: BridgeType.AVALANCHE_BTC_AVA;
+    signer: BtcSigner;
+    bitcoinFunctions: BitcoinFunctions;
+};
+type LombardBridgeInitializer = {
+    type: BridgeType.LOMBARD_BTC_TO_BTCB | BridgeType.LOMBARD_BTCB_TO_BTC;
+    evmSigner: EvmSignerWithMessage;
+    btcSigner: BtcSigner;
+    bitcoinFunctions: BitcoinFunctions;
+};
+type BridgeInitializer = EvmBridgeInitializer | AvaToBtcBridgeInitializer | BtcToAvaBridgeInitializer | LombardBridgeInitializer;
+declare const isLombardBridgeInitializer: (initializer: BridgeInitializer) => initializer is LombardBridgeInitializer;
+declare const isEvmBridgeInitializer: (initializer: BridgeInitializer) => initializer is EvmBridgeInitializer;
+declare const isAvaToBtcBridgeInitializer: (initializer: BridgeInitializer) => initializer is AvaToBtcBridgeInitializer;
+declare const isBtcToAvaBridgeInitializer: (initializer: BridgeInitializer) => initializer is BtcToAvaBridgeInitializer;
 type FeeParams = {
     asset: BridgeAsset;
     amount: bigint;
     sourceChain: Chain;
     targetChain: Chain;
-    provider?: Provider;
 };
 declare enum BridgeSignatureReason {
     AllowanceApproval = "allowance-approval",
-    TokensTransfer = "tokens-transfer"
+    TokensTransfer = "tokens-transfer",
+    WrapToken = "wrap-token"
 }
 type BridgeStepDetails = {
     currentSignature: number;
     requiredSignatures: number;
     currentSignatureReason: BridgeSignatureReason;
 };
+type GasSettings = {
+    price: bigint;
+    tip?: bigint;
+};
 type TransferParams = {
     asset: BridgeAsset;
     amount: bigint;
     fromAddress: string;
-    toAddress?: string;
+    toAddress: string;
     sourceChain: Chain;
     targetChain: Chain;
-    sourceProvider?: Provider;
-    targetProvider?: Provider;
+    gasSettings?: GasSettings;
     onStepChange?: (stepDetails: BridgeStepDetails) => void;
-    sign?: Signer;
 };
+type GasEstimationParams = Omit<TransferParams, 'onStepChange' | 'toAddress'>;
 type TrackingParams = {
     bridgeTransfer: BridgeTransfer;
-    sourceProvider?: Provider;
-    targetProvider?: Provider;
     updateListener: (transfer: BridgeTransfer) => void;
 };
+type AnalyzeTxParams = {
+    chainId: string;
+    from: string;
+    to: string;
+    tokenTransfers: {
+        from?: string;
+        to?: string;
+        symbol: string;
+    }[];
+};
+type AnalyzeTxResult = {
+    isBridgeTx: true;
+    bridgeType: BridgeType;
+    sourceChainId?: string;
+    targetChainId?: string;
+} | {
+    isBridgeTx: false;
+};
 type BridgeService = {
     type: BridgeType;
-    estimateGas: (params: TransferParams) => Promise<bigint>;
-    getAssets: () => Promise<ChainAssetMap>;
-    getFees: (params: FeeParams) => Promise<AssetFeeMap>;
+    analyzeTx: (params: AnalyzeTxParams) => AnalyzeTxResult;
+    estimateGas: (params: GasEstimationParams) => Promise<bigint>;
+    estimateReceiveAmount: (params: GasEstimationParams) => Promise<{
+        asset: Asset;
+        amount: bigint;
+    }>;
     transferAsset: (params: TransferParams) => Promise<BridgeTransfer>;
     trackTransfer: (transfer: TrackingParams) => {
         cancel: () => void;
         result: Promise<BridgeTransfer>;
     };
+    getAssets: () => ChainAssetMap;
+    getFees: (params: FeeParams) => Promise<AssetFeeMap>;
+    getMinimumTransferAmount: (params: FeeParams) => Promise<bigint>;
 };
 type BridgeServiceFactory = (environment: Environment) => Promise<BridgeService>;
 
@@ -144,39 +362,40 @@ declare enum TokenType {
     NATIVE = "native",
     ERC20 = "erc20"
 }
-type Asset = {
-    type: TokenType;
-    address?: Address;
+type BaseAsset = {
     name: string;
     symbol: string;
     decimals: number;
 };
+type Erc20Asset = BaseAsset & {
+    type: TokenType.ERC20;
+    address: Address;
+};
+type NativeAsset = BaseAsset & {
+    type: TokenType.NATIVE;
+};
+declare const isErc20Asset: (asset: Asset) => asset is Erc20Asset;
+declare const isNativeAsset: (asset: Asset) => asset is NativeAsset;
+type Asset = Erc20Asset | NativeAsset;
 type DestinationInfo = Record<string, BridgeType[]>;
 type BridgeAsset = Asset & {
     destinations: DestinationInfo;
 };
 type ChainAssetMap = Record<string, BridgeAsset[]>;
-type AssetFeeMap = Record<Address, bigint>;
+type AssetFeeMap = Record<string, Partial<Record<Address | 'NATIVE', bigint>>>;
 
 type BridgeServicesMap = Map<BridgeType, BridgeService>;
 type BridgeServiceConfig = {
     environment: Environment;
     enabledBridgeServices: BridgeServicesMap;
 };
-
-declare const createUnifiedBridgeService: ({ environment, enabledBridgeServices }: BridgeServiceConfig) => {
-    environment: Environment;
-    getAssets: () => Promise<ChainAssetMap>;
-    getFees: (params: FeeParams) => Promise<AssetFeeMap>;
-    estimateGas: (params: TransferParams) => Promise<bigint>;
+type UnifiedBridgeService = Omit<BridgeService, 'type'> & {
     canTransferAsset: (asset: BridgeAsset, targetChainId: string) => boolean;
-    transferAsset: (params: TransferParams) => Promise<BridgeTransfer>;
-    trackTransfer: (params: TrackingParams) => {
-        cancel: () => void;
-        result: Promise<BridgeTransfer>;
-    };
+    environment: Environment;
 };
 
+declare const createUnifiedBridgeService: ({ environment, enabledBridgeServices }: BridgeServiceConfig) => UnifiedBridgeService;
+
 type Caip2ChainId = {
     namespace: string;
     reference: string;
@@ -184,8 +403,16 @@ type Caip2ChainId = {
 declare const _default: {
     toJSON: (identifier: string) => Caip2ChainId;
     toString: ({ namespace, reference }: Caip2ChainId) => string;
+    toEip155HexChainId: ({ namespace, reference }: Caip2ChainId) => string;
 };
 
-declare const getEnabledBridgeServices: (environment: Environment, disabledBridgeTypes: BridgeType[]) => Promise<BridgeServicesMap>;
+/**
+ * Gets the estimated bridging time in hours for a given Lombard bridge type
+ * @param bridgeType - The bridge type (LOMBARD_BTC_TO_BTCB or LOMBARD_BTCB_TO_BTC)
+ * @returns The estimated bridging time in hours
+ */
+declare const getEstimatedBridgingTime: (bridgeType: BridgeType) => number | undefined;
+
+declare const getEnabledBridgeServices: (environment: Environment, enabledBridgeInitializers: BridgeInitializer[]) => Promise<BridgeServicesMap>;
 
-export { Asset, AssetFeeMap, BridgeAsset, BridgeService, BridgeServiceConfig, BridgeServiceFactory, BridgeServicesMap, BridgeSignatureReason, BridgeStepDetails, BridgeTransfer, BridgeType, Chain, ChainAssetMap, DestinationInfo, Dispatch, Environment, ErrorCode, ErrorReason, FeeParams, Hex, Provider, Signer, TokenType, TrackingParams, TransactionRequest, TransferParams, _default as caip2, createUnifiedBridgeService, getEnabledBridgeServices };
+export { AVALANCHE_FUJI_CHAIN, AVALANCHE_MAINNET_CHAIN, AnalyzeTxParams, AnalyzeTxResult, ArrayElement, Asset, AssetFeeMap, AvaToBtcBridgeInitializer, AvalancheChainIds, BITCOIN_MAINNET_CHAIN, BITCOIN_TESTNET_CHAIN, BTC_BRIDGE_TYPES, BitcoinChainIds, BitcoinFunctions, BitcoinInputUTXO, BitcoinInputUTXOWithOptionalScript, BitcoinTx, BridgeAsset, BridgeInitializer, BridgeService, BridgeServiceConfig, BridgeServiceFactory, BridgeServicesMap, BridgeSignatureReason, BridgeStepDetails, BridgeTransfer, BridgeType, BtcDispatch, BtcSign, BtcSigner, BtcToAvaBridgeInitializer, BtcTransactionRequest, Chain, ChainAssetMap, DestinationInfo, ETHEREUM_MAINNET_CHAIN, ETHEREUM_SEPOLIA_CHAIN, EVM_BRIDGE_TYPES, Environment, Erc20Asset, ErrorCode, ErrorReason, EthereumChainIds, EvmBridgeInitializer, EvmDispatch, EvmSign, EvmSignMessage, EvmSigner, EvmSignerWithMessage, EvmTransactionRequest, FeeParams, GasEstimationParams, GasSettings, Hex, LombardBridgeInitializer, NativeAsset, TokenType, TrackingParams, TransferParams, UnifiedBridgeService, _default as caip2, createUnifiedBridgeService, getEnabledBridgeServices, getEstimatedBridgingTime, isAvaToBtcBridgeInitializer, isBtcToAvaBridgeInitializer, isErc20Asset, isEvmBridgeInitializer, isLombardBridgeInitializer, isNativeAsset };