@stableflow/bridges 0.0.0-experimental-5a8afd7389-20260703

package/dist/index.d.ts

@@ -0,0 +1,323 @@
+import * as _stableflow_core from '@stableflow/core';
+import { Service, TokenConfig, WalletConfig, CancelablePromise, SubmitDepositTxResponse, TransactionStatus } from '@stableflow/core';
+import Big from 'big.js';
+
+declare const ServiceMap: Record<Service, any>;
+
+/**
+ * Serializable, unsigned EVM transaction data.
+ *
+ * This is what an API-driven custody integrator (e.g. an MPC wallet such as
+ * Fireblocks) receives. Stableflow builds the calldata; the integrator signs
+ * and broadcasts it through their own infrastructure, then reports the
+ * resulting hash back via `BridgeSFA.report`.
+ */
+interface EvmTxData {
+    chainId: number;
+    from: string;
+    to: string;
+    /** Hex-encoded calldata. `0x` for a plain native-token transfer. */
+    data: string;
+    /** Native token amount in wei, as a decimal string. */
+    value: string;
+    /** Optional gas limit as a decimal string. */
+    gasLimit?: string;
+}
+/**
+ * EIP-712 typed data for an ERC20 `Permit`, returned unsigned so an external
+ * signer (MPC/Fireblocks) can produce the signature. Nothing is signed or
+ * verified inside the SDK for this payload.
+ */
+interface PermitTypedData {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+    };
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    values: {
+        owner: string;
+        spender: string;
+        value: string;
+        nonce: string;
+        deadline: number;
+    };
+    deadline: number;
+    nonce: number;
+    token: string;
+    spender: string;
+    owner: string;
+}
+/**
+ * Result of `BridgeSFA.buildTransaction`.
+ *
+ * Depending on the route, the integrator may need to: broadcast `approveTx`
+ * (optionally `approveResetTx` first on Ethereum), sign `permitTypedData`,
+ * and always broadcast the main `tx`. See `BridgeSFA.buildTransaction`.
+ */
+interface BuildTransactionResult {
+    chainId: number;
+    from: string;
+    /** Present when `quote.needApprove === true`. */
+    approveTx?: EvmTxData;
+    /**
+     * Present when `quote.needApprove === true` and the source chain is Ethereum.
+     * Some Ethereum tokens (e.g. USDT) require resetting the allowance to 0
+     * before setting a new non-zero allowance.
+     */
+    approveResetTx?: EvmTxData;
+    /** Present when `quote.needPermit === true`. Must be signed off-chain. */
+    permitTypedData?: PermitTypedData;
+    /** The main source-chain transaction to sign and broadcast. */
+    tx: EvmTxData;
+}
+/**
+ * Build the main unsigned source-chain transaction from a quote, mirroring the
+ * branching in `BridgeSFA.send` but producing serializable calldata instead of
+ * signing/broadcasting.
+ */
+declare const buildSendTx: (serviceType: Service, quote: any) => EvmTxData;
+/**
+ * Build the ERC20 approve transaction(s) for a quote that requires approval.
+ * On Ethereum an additional `approveResetTx` (approve 0) is returned so the
+ * integrator can reset a stale allowance before setting a new one.
+ */
+declare const buildApproveTx: (serviceType: Service, quote: any) => {
+    approveTx?: EvmTxData;
+    approveResetTx?: EvmTxData;
+};
+/**
+ * Build the EIP-712 `Permit` typed data for a permit-required route, returned
+ * unsigned. The integrator signs it with their MPC/Fireblocks signer, splits
+ * the signature into `v/r/s`, and passes the assembled `permitSignature` to
+ * `BridgeSFA.report`.
+ */
+declare const buildPermitTypedData: (params: {
+    permitToken: TokenConfig;
+    permitAmountWei: string;
+    permitSpender: string;
+    owner: string;
+}) => Promise<PermitTypedData>;
+
+/**
+ * Normalized ERC20 permit signature passed to `BridgeSFA.send` / `BridgeSFA.report`
+ * when a route requires a permit (`quote.needPermit === true`).
+ */
+interface PermitSignature {
+    amount: string;
+    deadline: number;
+    nonce: string;
+    owner: string;
+    r: string;
+    s: string;
+    v: 27 | 28;
+}
+interface GetAllQuoteParams {
+    singleService?: Service;
+    disabledServices?: Service[];
+    dry?: boolean;
+    prices: Record<string, string>;
+    fromToken: TokenConfig;
+    toToken: TokenConfig;
+    wallet: WalletConfig;
+    evmWallet?: WalletConfig | null;
+    evmAddress?: string | null;
+    recipient: string;
+    refundTo: string;
+    amountWei: string;
+    slippageTolerance: number;
+    minInputAmount?: string;
+    /** @deprecated Please migrate to oneclickParams */
+    appFees?: {
+        recipient: string;
+        fee: number;
+    }[];
+    oneclickParams?: {
+        appFees?: {
+            recipient: string;
+            fee: number;
+        }[];
+        swapType?: "EXACT_INPUT" | "EXACT_OUTPUT" | "FLEX_INPUT";
+        isProxy?: boolean;
+    };
+}
+/**
+ * Full cross-chain bridge API (multi-route quote, send, status).
+ * Install `@stableflow/bridges` alongside `@stableflow/core`.
+ */
+declare class BridgeSFA {
+    static getAllQuote(params: GetAllQuoteParams): Promise<Array<{
+        serviceType: Service;
+        quote?: any;
+        error?: string;
+    }>>;
+    static send(serviceType: Service, params: {
+        wallet: any;
+        quote: any;
+        permitSignature?: PermitSignature;
+    }): Promise<string>;
+    /**
+     * Build the backend report payload for a submitted source-chain transaction.
+     * Shared by `send` (fire-and-forget) and `report` (awaited).
+     */
+    private static buildReportData;
+    /**
+     * API-driven custody: build the serializable, unsigned transaction data for a
+     * route WITHOUT a signer. Intended for MPC wallets (e.g. Fireblocks) that sign
+     * and broadcast through their own infrastructure.
+     *
+     * Returns any required `approveTx` (and `approveResetTx` on Ethereum), the
+     * `permitTypedData` to sign off-chain when `quote.needPermit`, and the main
+     * `tx`. After the integrator broadcasts `tx`, call `BridgeSFA.report` with the
+     * resulting hash (and the permit signature, if any) so StableFlow can execute
+     * the destination leg.
+     *
+     * EVM only for now; non-EVM source chains throw.
+     */
+    static buildTransaction(serviceType: Service, params: {
+        quote: any;
+    }): Promise<BuildTransactionResult>;
+    /**
+     * API-driven custody: report an externally signed & broadcast source-chain
+     * transaction back to StableFlow so it can track and execute the destination
+     * leg. Pair with `BridgeSFA.buildTransaction`.
+     *
+     * When `quote.needPermit === true`, `permitSignature` is required.
+     */
+    static report(serviceType: Service, params: {
+        quote: any;
+        hash: string;
+        permitSignature?: PermitSignature;
+    }): CancelablePromise<SubmitDepositTxResponse>;
+    static getStatus(serviceType: Service, params: {
+        quote: any;
+        hash: string;
+    }): Promise<{
+        status: TransactionStatus;
+        toChainTxHash?: string;
+    }>;
+}
+
+interface LayerZeroChainConfig {
+    eid: number;
+    chainKey: string;
+    blockTime: number;
+}
+
+declare const getQuoteModes: (params: {
+    quoteData?: any;
+    bridgeStore?: {
+        quoteDataService: Service;
+    };
+}) => {
+    isExactOutput: boolean;
+    isOneClickService: boolean;
+    isQuoteParamDepositAddress: boolean;
+    isPermitWithNonce: boolean;
+};
+
+declare function addressToBytes32(chainType: string, address: string): string;
+
+declare const formatQuoteError: (error: any, options: {
+    service: Service;
+    fromToken: TokenConfig;
+}) => {
+    serviceType: "oneclick";
+    error: string;
+} | {
+    serviceType: "usdt0" | "cctp" | "fraxzero" | "fraxzero-oneclick" | "oneclick-fraxzero" | "usdt0-oneclick" | "oneclick-usdt0" | "native";
+    error: any;
+};
+
+declare function quoteSignature(params: any): Promise<any>;
+
+declare const formatNumber: (value: string | number | Big.Big | undefined, precision: number, isSimple?: boolean, options?: {
+    prefix?: string;
+    isLTIntegerZero?: boolean;
+    isZeroPrecision?: boolean;
+    isShort?: boolean;
+    isShortUppercase?: boolean;
+    round?: Big.RoundingMode;
+    isLessPrecision?: boolean;
+}) => any;
+
+declare const getHopMsgFee: (params: any) => Promise<bigint>;
+
+interface Usdt0Config extends LayerZeroChainConfig {
+    contractAddress: string;
+    oft?: string;
+    oftLegacy?: string;
+    oftMultiHopComposer?: string;
+    oftTetherTokenOFTExtension?: string;
+    confirmations: number;
+    lzReceiveOptionGas: number;
+    lzReceiveOptionGasLegacy: number;
+    composeOptionGas?: number;
+    oftApprovalRequired?: boolean;
+    oftLegacyApprovalRequired?: boolean;
+}
+declare const USDT0_CONFIG: Record<string, Usdt0Config>;
+declare const LZ_RECEIVE_VALUE: Record<string, any>;
+declare const USDT0_LEGACY_MESH_TRANSFTER_FEE = 0.0003;
+declare const DATA_HEX_PROTOBUF_EXTRA = 3;
+declare const SIGNATURE_SIZE = 67;
+
+declare const OFT_ABI: ({
+    inputs: never[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+} | {
+    inputs: ({
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    } | {
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    })[];
+    name: string;
+    outputs: {
+        components: ({
+            internalType: string;
+            name: string;
+            type: string;
+            components?: undefined;
+        } | {
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        })[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+})[];
+
+declare const FRAXZERO_MIDDLE_TOKEN_USDC: _stableflow_core.TokenConfig;
+declare const FRAXZERO_MIDDLE_TOKEN_FRXUSD: _stableflow_core.TokenConfig;
+
+export { BridgeSFA, type BuildTransactionResult, DATA_HEX_PROTOBUF_EXTRA, type EvmTxData, FRAXZERO_MIDDLE_TOKEN_FRXUSD, FRAXZERO_MIDDLE_TOKEN_USDC, type GetAllQuoteParams, LZ_RECEIVE_VALUE, OFT_ABI, type PermitSignature, type PermitTypedData, SIGNATURE_SIZE, ServiceMap, USDT0_CONFIG, USDT0_LEGACY_MESH_TRANSFTER_FEE, addressToBytes32, buildApproveTx, buildPermitTypedData, buildSendTx, formatNumber, formatQuoteError, getHopMsgFee, getQuoteModes, quoteSignature };