@avalabs/bridge-unified 0.0.0-hello-world-20230824162438 → 0.0.0-project-fusion-pr-20260112192135

package/dist/index.d.ts

@@ -1,36 +1,392 @@
-import * as _internal_bridge_shared from '@internal/bridge-shared';
-import { Environment, MaybePromise, NativeToken } from '@internal/bridge-shared';
+import { Address } from 'viem';
+import { z } from 'zod';
 
-type BridgeServiceConfig = {
-    environment: `${Environment}`;
-    getChainNativeAsset: ({ evmChainId }: {
-        evmChainId: string;
-    }) => MaybePromise<NativeToken>;
-    getChainErc20Asset: ({ evmChainId, address }: {
-        evmChainId: string;
-        address: string;
-    }) => MaybePromise<NativeToken>;
-};
-declare const createUnifiedBridgeService: (_options: BridgeServiceConfig) => {
-    planBridgeJourney: (_params: {
-        fromChainId: string;
-        toChainId: string;
-        fromToken: _internal_bridge_shared.Token;
-    }) => {
-        fromChainId: string;
-        toChainId: string;
-        bridgePlatform: _internal_bridge_shared.BridgePlatform;
-        fromToken: _internal_bridge_shared.Token;
-        toToken: _internal_bridge_shared.Token;
+type Chain = {
+    chainName: string;
+    chainId: string;
+    rpcUrl: string;
+    utilityAddresses?: {
+        multicall: Address;
+    };
+    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"
+}
+
+/**
+ * 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;
     }[];
-    executeBridgeJourneyStep: (_params: {
-        stepIndex: number;
-        journey: unknown;
-    }) => Promise<never>;
-    checkForPendingBridgeJourney: ({ address: _address, chainIds: _chainIds, }: {
-        address: `0x${string}`;
-        chainIds: string[];
-    }) => Promise<never>;
+}
+
+type Hex = `0x${string}`;
+type EvmTransactionRequest = {
+    type?: number | null;
+    data?: Hex | null;
+    from: Hex;
+    gas?: bigint;
+    nonce?: number;
+    to?: Hex | null;
+    value?: bigint;
+    gasPrice?: bigint | null;
+    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 EvmSigner = {
+    sign: EvmSign;
+};
+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;
+};
+
+declare enum ErrorCode {
+    BRIDGE_NOT_AVAILABLE = 5001,
+    INITIALIZATION_FAILED = 5002,
+    INVALID_PARAMS = 5003,
+    TIMEOUT = 5004,
+    TRANSACTION_REVERTED = 5005
+}
+declare enum ErrorReason {
+    ASSET_NOT_SUPPORTED = "ASSET_NOT_SUPPORTED",// the provided asset is not supported by the bridge
+    CHAIN_NOT_SUPPORTED = "CHAIN_NOT_SUPPORTED",// the provided source or target chain is not supported by the bridge
+    CONFIG_NOT_AVAILABLE = "CONFIG_NOT_AVAILABLE",// error while fetching or parsing the config
+    CONFIRMATION_COUNT_UNKNOWN = "CONFIRMATION_COUNT_UNKNOWN",// required confirmation count of the source or target chain is unknown
+    ENVIRONMENT_NOT_SUPPORTED = "ENVIRONMENT_NOT_SUPPORTED",// bridge does not support specified environment
+    IDENTICAL_CHAINS_PROVIDED = "IDENTICAL_CHAINS_PROVIDED",// provided source and target chains are the same
+    INCORRECT_ADDRESS_PROVIDED = "INCORRECT_ADDRESS_PROVIDED",// the sender or recipient address is incorrect
+    INCORRECT_AMOUNT_PROVIDED = "INCORRECT_AMOUNT_PROVIDED",// the transfer amount is incorrect (e.g.: lesser than or equal to zero)
+    INCORRECT_HASH_PROVIDED = "INCORRECT_HASH_PROVIDED",// the transaction is not hex
+    INCORRECT_PROVIDER_PROVIDED = "INCORRECT_PROVIDER_PROVIDED",// The provided provider is incorrect type (Provider VS BitcoinProvider)
+    INCORRECT_SIGNER_PROVIDED = "INCORRECT_SIGNER_PROVIDED",// The provided signer is incorrect type
+    INCORRECT_TXHASH_PROVIDED = "INCORRECT_TXHASH_PROVIDED",// the sourceTxHash or targetTxHash is incorrect
+    INVALID_PARAMS = "INVALID_PARAMS",// generic error with the params
+    UNKNOWN = "UNKNOWN",// generic, not specified error
+    VULNERABLE_TOKEN_APPROVAL_ADDRESS = "VULNERABLE_TOKEN_APPROVAL_ADDRESS",// error when the address has token approvals for addresses involved in the multichain incident
+    WARDEN_CONFIG_MISMATCH = "WARDEN_CONFIG_MISMATCH",// error when warden config was not found or it is over the mismatch threshold
+    WARDEN_CONFIG_MISSING_NETWORK = "WARDEN_CONFIG_MISSING_NETWORK",// fetched warden config does not contain network IDs
+    ADDRESS_IS_BLOCKED = "ADDRESS_IS_BLOCKED"
+}
+
+type BridgeTransfer = {
+    type: BridgeType;
+    environment: Environment;
+    fromAddress: string;
+    toAddress: string;
+    amount: bigint;
+    asset: BridgeAsset;
+    completedAt?: number;
+    errorCode?: ErrorCode;
+    bridgeFee: bigint;
+    sourceChain: Chain;
+    sourceStartedAt: number;
+    sourceTxHash: string;
+    sourceNetworkFee?: bigint;
+    sourceConfirmationCount: number;
+    sourceRequiredConfirmationCount: number;
+    targetChain: Chain;
+    targetStartedAt?: number;
+    targetTxHash?: string;
+    targetNetworkFee?: bigint;
+    targetConfirmationCount: number;
+    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 {
+    AVALANCHE_EVM = "avalanche-evm",
+    AVALANCHE_BTC_AVA = "avalanche-btc-ava",
+    AVALANCHE_AVA_BTC = "avalanche-ava-btc",
+    CCTP = "cctp",
+    ICTT_ERC20_ERC20 = "ictt-erc20-erc20"
+}
+declare const BTC_BRIDGE_TYPES: readonly [BridgeType.AVALANCHE_AVA_BTC, BridgeType.AVALANCHE_BTC_AVA];
+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 BridgeInitializer = EvmBridgeInitializer | AvaToBtcBridgeInitializer | BtcToAvaBridgeInitializer;
+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;
+};
+declare enum BridgeSignatureReason {
+    AllowanceApproval = "allowance-approval",
+    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;
+    sourceChain: Chain;
+    targetChain: Chain;
+    gasSettings?: GasSettings;
+    onStepChange?: (stepDetails: BridgeStepDetails) => void;
+};
+type GasEstimationParams = Omit<TransferParams, 'onStepChange' | 'toAddress'>;
+type TrackingParams = {
+    bridgeTransfer: BridgeTransfer;
+    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;
+    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>;
+
+declare enum TokenType {
+    NATIVE = "native",
+    ERC20 = "erc20"
+}
+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<string, Partial<Record<Address | 'NATIVE', bigint>>>;
+
+type BridgeServicesMap = Map<BridgeType, BridgeService>;
+type BridgeServiceConfig = {
+    environment: Environment;
+    enabledBridgeServices: BridgeServicesMap;
+};
+type UnifiedBridgeService = Omit<BridgeService, 'type'> & {
+    canTransferAsset: (asset: BridgeAsset, targetChainId: string) => boolean;
+    environment: Environment;
+};
+
+declare const createUnifiedBridgeService: ({ environment, enabledBridgeServices }: BridgeServiceConfig) => UnifiedBridgeService;
+
+type Caip2ChainId = {
+    namespace: string;
+    reference: string;
+};
+declare const _default: {
+    toJSON: (identifier: string) => Caip2ChainId;
+    toString: ({ namespace, reference }: Caip2ChainId) => string;
+    toEip155HexChainId: ({ namespace, reference }: Caip2ChainId) => string;
+};
+
+declare const getEnabledBridgeServices: (environment: Environment, enabledBridgeInitializers: BridgeInitializer[]) => Promise<BridgeServicesMap>;
 
-export { BridgeServiceConfig, createUnifiedBridgeService };
+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, EvmSigner, EvmTransactionRequest, FeeParams, GasEstimationParams, GasSettings, Hex, NativeAsset, TokenType, TrackingParams, TransferParams, UnifiedBridgeService, _default as caip2, createUnifiedBridgeService, getEnabledBridgeServices, isAvaToBtcBridgeInitializer, isBtcToAvaBridgeInitializer, isErc20Asset, isEvmBridgeInitializer, isNativeAsset };