@sodax/sdk 1.3.1-beta-rc1 → 1.3.1-beta-rc3

package/dist/index.cjs

@@ -17,6 +17,8 @@ var coreProtoTs = require('@injectivelabs/core-proto-ts');
 var rlp = require('rlp');
 var anchor = require('@coral-xyz/anchor');
 var BN = require('bn.js');
+var bitcoin = require('bitcoinjs-lib');
+var ecc = require('@bitcoinerlab/secp256k1');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -44,6 +46,8 @@ var BigNumber4__default = /*#__PURE__*/_interopDefault(BigNumber4);
 var rlp__namespace = /*#__PURE__*/_interopNamespace(rlp);
 var anchor__namespace = /*#__PURE__*/_interopNamespace(anchor);
 var BN__default = /*#__PURE__*/_interopDefault(BN);
+var bitcoin__namespace = /*#__PURE__*/_interopNamespace(bitcoin);
+var ecc__namespace = /*#__PURE__*/_interopNamespace(ecc);
 
 // src/shared/abis/asset-manager.abi.ts
 var assetManagerAbi = [
@@ -6855,7 +6859,7 @@ var stakingRouterAbi = [
 ];
 
 // ../types/dist/constants/index.js
-var CONFIG_VERSION = 27;
+var CONFIG_VERSION = 28;
 var AVALANCHE_MAINNET_CHAIN_ID = "0xa86a.avax";
 var ARBITRUM_MAINNET_CHAIN_ID = "0xa4b1.arbitrum";
 var BASE_MAINNET_CHAIN_ID = "0x2105.base";
@@ -6872,6 +6876,7 @@ var HYPEREVM_MAINNET_CHAIN_ID = "hyper";
 var LIGHTLINK_MAINNET_CHAIN_ID = "lightlink";
 var NEAR_MAINNET_CHAIN_ID = "near";
 var ETHEREUM_MAINNET_CHAIN_ID = "ethereum";
+var BITCOIN_MAINNET_CHAIN_ID = "bitcoin";
 var REDBELLY_MAINNET_CHAIN_ID = "redbelly";
 var KAIA_MAINNET_CHAIN_ID = "0x2019.kaia";
 var HUB_CHAIN_IDS = [SONIC_MAINNET_CHAIN_ID];
@@ -6892,6 +6897,7 @@ var CHAIN_IDS = [
   LIGHTLINK_MAINNET_CHAIN_ID,
   NEAR_MAINNET_CHAIN_ID,
   ETHEREUM_MAINNET_CHAIN_ID,
+  BITCOIN_MAINNET_CHAIN_ID,
   REDBELLY_MAINNET_CHAIN_ID,
   KAIA_MAINNET_CHAIN_ID
 ];
@@ -7006,6 +7012,12 @@ var baseChainInfo = {
     type: "EVM",
     chainId: 1
   },
+  [BITCOIN_MAINNET_CHAIN_ID]: {
+    name: "Bitcoin",
+    id: BITCOIN_MAINNET_CHAIN_ID,
+    type: "BITCOIN",
+    chainId: "bitcoin"
+  },
   [REDBELLY_MAINNET_CHAIN_ID]: {
     name: "Redbelly",
     id: REDBELLY_MAINNET_CHAIN_ID,
@@ -7036,6 +7048,7 @@ var ChainIdToIntentRelayChainId = {
   [LIGHTLINK_MAINNET_CHAIN_ID]: 27756n,
   [NEAR_MAINNET_CHAIN_ID]: 15n,
   [ETHEREUM_MAINNET_CHAIN_ID]: 2n,
+  [BITCOIN_MAINNET_CHAIN_ID]: 627463n,
   [REDBELLY_MAINNET_CHAIN_ID]: 726564n,
   [KAIA_MAINNET_CHAIN_ID]: 27489n
 };
@@ -7948,6 +7961,42 @@ var spokeChainConfig = {
     rpcUrl: "https://injective-rpc.publicnode.com:443",
     walletAddress: ""
   },
+  [BITCOIN_MAINNET_CHAIN_ID]: {
+    addresses: {
+      assetManager: "bc1pxguu2r4p9jcxp3gj7dh4r4jd9qzccwpyap3nj5nlapy28s76lhrqw522fz"
+    },
+    chain: baseChainInfo[BITCOIN_MAINNET_CHAIN_ID],
+    bnUSD: "no",
+    nativeToken: "BTC",
+    supportedTokens: {
+      BTC: {
+        symbol: "BTC",
+        name: "Bitcoin",
+        decimals: 8,
+        address: "0:0",
+        xChainId: BITCOIN_MAINNET_CHAIN_ID
+      },
+      bnUSD: {
+        symbol: "bnUSD",
+        name: "bnUSD",
+        decimals: 18,
+        address: "0:0",
+        xChainId: BITCOIN_MAINNET_CHAIN_ID
+      },
+      BUSD: {
+        symbol: "BUSD",
+        name: "BUSDSTABLECOIN",
+        decimals: 6,
+        address: "897442:43",
+        xChainId: BITCOIN_MAINNET_CHAIN_ID
+      }
+    },
+    radfiApiUrl: "https://api.canary.radfi.co/api",
+    radfiApiKey: "",
+    radfiUmsUrl: "https://ums.radfi.co/api",
+    network: "MAINNET",
+    rpcUrl: "https://mempool.space/api"
+  },
   [STELLAR_MAINNET_CHAIN_ID]: {
     addresses: {
       connection: "CDFQDDPUPAM3XPGORHDOEFRNLMKOH3N3X6XTXNLSXJQXIU3RVCM3OPEP",
@@ -9444,6 +9493,22 @@ var hubAssets = {
       name: "RedBelly POL",
       vault: SodaTokens.sodaPOL.address
     }
+  },
+  [BITCOIN_MAINNET_CHAIN_ID]: {
+    [spokeChainConfig[BITCOIN_MAINNET_CHAIN_ID].supportedTokens.BTC.address]: {
+      asset: "0xeb0393893b5bf98a50073d6740738b08e575058b",
+      decimal: 8,
+      symbol: "BTC",
+      name: "Bitcoin",
+      vault: "0x7A1A5555842Ad2D0eD274d09b5c4406a95799D5d"
+    },
+    [spokeChainConfig[BITCOIN_MAINNET_CHAIN_ID].supportedTokens.BUSD.address]: {
+      asset: "0xdb41c7d09406026d4582bc2fc6d6319c323fe1bb",
+      decimal: 6,
+      symbol: "BUSD",
+      name: "BUSD.BUSD.BUSD",
+      vault: "0xE801CA34E19aBCbFeA12025378D19c4FBE250131"
+    }
   }
 };
 var solverConfig = {
@@ -9584,6 +9649,10 @@ var swapSupportedTokens = {
     spokeChainConfig[NEAR_MAINNET_CHAIN_ID].supportedTokens.USDC,
     spokeChainConfig[NEAR_MAINNET_CHAIN_ID].supportedTokens.USDT
   ],
+  [BITCOIN_MAINNET_CHAIN_ID]: [
+    spokeChainConfig[BITCOIN_MAINNET_CHAIN_ID].supportedTokens.BTC
+    // spokeChainConfig[BITCOIN_MAINNET_CHAIN_ID].supportedTokens.BUSD, // TODO: re-enable when trading wallet balance is ready
+  ],
   [ETHEREUM_MAINNET_CHAIN_ID]: [
     spokeChainConfig[ETHEREUM_MAINNET_CHAIN_ID].supportedTokens.ETH,
     spokeChainConfig[ETHEREUM_MAINNET_CHAIN_ID].supportedTokens.bnUSD,
@@ -9785,6 +9854,9 @@ var moneyMarketSupportedTokens = {
     spokeChainConfig[KAIA_MAINNET_CHAIN_ID].supportedTokens.bnUSD,
     spokeChainConfig[KAIA_MAINNET_CHAIN_ID].supportedTokens.USDT,
     spokeChainConfig[KAIA_MAINNET_CHAIN_ID].supportedTokens.SODA
+  ],
+  [BITCOIN_MAINNET_CHAIN_ID]: [
+    spokeChainConfig[BITCOIN_MAINNET_CHAIN_ID].supportedTokens.BTC
   ]
 };
 var moneyMarketReserveAssets = [
@@ -9809,7 +9881,7 @@ var defaultSharedConfig = {
 };
 
 // ../types/dist/common/index.js
-var ChainTypeArr = ["ICON", "EVM", "INJECTIVE", "SUI", "STELLAR", "SOLANA", "NEAR"];
+var ChainTypeArr = ["ICON", "EVM", "INJECTIVE", "SUI", "STELLAR", "SOLANA", "NEAR", "BITCOIN"];
 
 // ../types/dist/injective/index.js
 var InjectiveExecuteResponse = class _InjectiveExecuteResponse {
@@ -9828,6 +9900,17 @@ var InjectiveExecuteResponse = class _InjectiveExecuteResponse {
     return response;
   }
 };
+
+// ../types/dist/btc/index.js
+function detectBitcoinAddressType(address) {
+  if (address.startsWith("bc1p") || address.startsWith("tb1p"))
+    return "P2TR";
+  if (address.startsWith("bc1") || address.startsWith("tb1"))
+    return "P2WPKH";
+  if (address.startsWith("1") || address.startsWith("m") || address.startsWith("n"))
+    return "P2PKH";
+  throw new Error(`Unknown Bitcoin address type: ${address}`);
+}
 var DEFAULT_MAX_RETRY = 3;
 var DEFAULT_RELAY_TX_TIMEOUT = 12e4;
 var DEFAULT_RETRY_DELAY_MS = 2e3;
@@ -21206,6 +21289,714 @@ var SolanaSpokeService = class _SolanaSpokeService {
     }
   }
 };
+
+// src/shared/entities/btc/RadfiProvider.ts
+var RadfiProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async authenticate(params) {
+    const res = await this.request("/auth/authenticate", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.message || "Radfi authentication failed");
+    }
+    return res.json().then((r) => ({
+      accessToken: r.data?.accessToken ?? "",
+      refreshToken: r.data?.refreshToken ?? "",
+      tradingAddress: r.data?.tradingAddress ?? r.data?.wallet?.tradingAddress ?? ""
+    }));
+  }
+  async refreshAccessToken(refreshToken) {
+    const res = await this.request("/auth/refresh-token", {
+      method: "POST",
+      body: JSON.stringify({ refreshToken })
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.message || "Token refresh failed");
+    }
+    return res.json().then((r) => ({
+      accessToken: r.data?.accessToken ?? "",
+      refreshToken: r.data?.refreshToken ?? refreshToken
+    }));
+  }
+  async createTradingWallet(params, accessToken) {
+    const res = await this.request("/wallets", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken || this.config.apiKey}`
+      },
+      body: JSON.stringify(params)
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.message || "Failed to create trading wallet");
+    }
+    return res.json().then((r) => r.data);
+  }
+  async getTradingWallet(userAddress, accessToken) {
+    const res = await this.request(`/wallets/details/${userAddress}`, {
+      method: "GET",
+      headers: accessToken ? { Authorization: `Bearer ${accessToken}` } : {}
+    });
+    if (!res.ok) {
+      throw new Error("Trading wallet not found");
+    }
+    const data = await res.json().then((r) => r.data);
+    if (!data) throw new Error("Trading wallet not found");
+    return data;
+  }
+  async getBalance(address) {
+    if (!this.config.umsUrl) {
+      throw new Error("RadfiConfig.umsUrl is required for getBalance");
+    }
+    const umsUrl = this.config.umsUrl;
+    const res = await fetch(`${umsUrl}/wallets/balance?address=${address}`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!res.ok) {
+      throw new Error("Failed to fetch wallet balance");
+    }
+    const { data } = await res.json();
+    return {
+      btcSatoshi: BigInt(data.btcSatoshi ?? "0"),
+      pendingSatoshi: BigInt(data.pendingSatoshi ?? "0"),
+      externalPendingSatoshi: BigInt(data.externalPendingSatoshi ?? "0"),
+      totalUtxos: Number(data.totalUtxos ?? 0)
+    };
+  }
+  async checkIfTradingWalletExists(userAddress) {
+    try {
+      await this.getTradingWallet(userAddress);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  async createWithdrawTransaction(params, accessToken) {
+    const res = await this.request("/sodax/transaction", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken ?? this.config.apiKey}`
+      },
+      body: JSON.stringify({
+        type: "sodax-withdraw",
+        params: {
+          amount: params.amount.toString(),
+          tokenId: params.token,
+          sodaxData: params.data
+        }
+      })
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.message || "Radfi transaction request failed");
+    }
+    return res.json().then((r) => r.data);
+  }
+  async requestRadfiSignature(params, accessToken) {
+    const res = await this.request("/sodax/transaction/sign", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken ?? this.config.apiKey}`
+      },
+      body: JSON.stringify({
+        type: "sodax-withdraw",
+        params
+      })
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.message || "Radfi signature request failed");
+    }
+    return res.json().then((r) => r.data.txId);
+  }
+  /**
+   * Fetch expired (or near-expiry) UTXOs for a trading wallet address from UMS API.
+   */
+  async getExpiredUtxos(tradingAddress, params) {
+    if (!this.config.umsUrl) {
+      throw new Error("RadfiConfig.umsUrl is required for getExpiredUtxos");
+    }
+    const page = params?.page ?? 1;
+    const pageSize = params?.pageSize ?? 100;
+    const url = `${this.config.umsUrl}/utxos?address_eq=${tradingAddress}&isSpent_eq=false&isExpired_eq=true&page=${page}&pageSize=${pageSize}`;
+    const res = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!res.ok) {
+      throw new Error("Failed to fetch expired UTXOs");
+    }
+    return res.json();
+  }
+  /**
+   * Build a renew-utxo transaction via the Radfi API.
+   * Returns a PSBT that needs to be signed by the user.
+   */
+  async buildRenewUtxoTransaction(params, accessToken) {
+    const res = await this.request("/transactions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      },
+      body: JSON.stringify({
+        type: "renew-utxo",
+        params: {
+          userAddress: params.userAddress,
+          txIdVouts: params.txIdVouts
+        }
+      })
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.message || "Failed to build renew-utxo transaction");
+    }
+    return res.json().then((r) => r.data);
+  }
+  /**
+   * Sign and broadcast a renew-utxo transaction via the Radfi API.
+   * The user signs the PSBT first, then Radfi co-signs and broadcasts.
+   */
+  async signAndBroadcastRenewUtxo(params, accessToken) {
+    const res = await this.request("/transactions/sign", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      },
+      body: JSON.stringify({
+        type: "renew-utxo",
+        params
+      })
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.message || "Failed to sign and broadcast renew-utxo transaction");
+    }
+    return res.json().then((r) => r.data.txId);
+  }
+  async request(endpoint, options) {
+    return fetch(`${this.config.url}${endpoint}`, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers || {}
+      }
+    });
+  }
+};
+bitcoin__namespace.initEccLib(ecc__namespace);
+var BITCOIN_DEFAULT_FEE_RATE = 3;
+var DUST_THRESHOLD = 546;
+function normalizePsbtToBase64(signedPsbt) {
+  const isHex = /^[0-9a-fA-F]+$/.test(signedPsbt);
+  return isHex ? Buffer.from(signedPsbt, "hex").toString("base64") : signedPsbt;
+}
+var BitcoinBaseSpokeProvider = class _BitcoinBaseSpokeProvider {
+  rpcUrl;
+  network;
+  chainConfig;
+  radfi;
+  walletMode;
+  radfiAccessToken = "";
+  constructor(config, radfiConfig, walletMode = "USER", rpcURL) {
+    this.chainConfig = config;
+    this.rpcUrl = rpcURL ?? config.rpcUrl;
+    this.network = config.network === "TESTNET" ? bitcoin__namespace.networks.testnet : bitcoin__namespace.networks.bitcoin;
+    this.radfi = new RadfiProvider(radfiConfig);
+    this.walletMode = walletMode;
+  }
+  setRadfiAccessToken(token) {
+    this.radfiAccessToken = token;
+  }
+  /**
+   * Get current fee estimates
+   */
+  async getFeeEstimate(targetBlocks = 6) {
+    try {
+      const response = await fetch(`${this.rpcUrl}/fee-estimates`);
+      if (!response.ok) {
+        return BITCOIN_DEFAULT_FEE_RATE;
+      }
+      const feeEstimates = await response.json();
+      return feeEstimates[targetBlocks] ?? BITCOIN_DEFAULT_FEE_RATE;
+    } catch {
+      return BITCOIN_DEFAULT_FEE_RATE;
+    }
+  }
+  static async getBalance(tokenAddress, provider) {
+    const walletAddress = await provider.walletProvider.getWalletAddress();
+    if (!tokenAddress || tokenAddress === "0x" || tokenAddress === "BTC") {
+      const utxos = await provider.fetchUTXOs(walletAddress);
+      const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
+      return BigInt(totalBalance);
+    }
+    throw new Error("Token balance queries not yet implemented for non-BTC assets");
+  }
+  async fetchScriptPubKey(utxo, provider) {
+    const txHex = await provider.fetchRawTransaction(utxo.txid);
+    const tx = bitcoin__namespace.Transaction.fromHex(txHex);
+    const out = tx.outs[utxo.vout];
+    if (!out) {
+      throw new Error(`UTXO not found: ${utxo.txid}:${utxo.vout}`);
+    }
+    return out.script.toString("hex");
+  }
+  /**
+   * Build a priority Bitcoin transaction with proper fee calculation
+   */
+  static async buildBitcoinTransaction(utxos, outputs, changeAddress, provider, feeRate) {
+    const psbt = new bitcoin__namespace.Psbt({ network: provider.network });
+    const effectiveFeeRate = feeRate ?? await provider.getFeeEstimate();
+    let inputSum = 0;
+    const outputSum = outputs.reduce((sum, o) => sum + o.value, 0);
+    for (const utxo of utxos) {
+      if (!utxo.status.confirmed) continue;
+      const scriptPubKey = await provider.fetchScriptPubKey(utxo, provider);
+      const isTaproot = scriptPubKey.startsWith("51");
+      const isSegwitV0 = scriptPubKey.startsWith("00");
+      if (isTaproot) {
+        if (!provider.walletProvider.getPublicKey) {
+          throw new Error("Missing public key for P2TR input");
+        }
+        const tapInternalKey = await provider.walletProvider.getPublicKey();
+        psbt.addInput({
+          hash: utxo.txid,
+          index: utxo.vout,
+          witnessUtxo: {
+            script: Buffer.from(scriptPubKey, "hex"),
+            value: utxo.value
+          },
+          tapInternalKey: Buffer.from(tapInternalKey, "hex")
+        });
+      } else if (isSegwitV0) {
+        psbt.addInput({
+          hash: utxo.txid,
+          index: utxo.vout,
+          witnessUtxo: {
+            script: Buffer.from(scriptPubKey, "hex"),
+            value: utxo.value
+          }
+        });
+      } else {
+        const txHex = await provider.fetchRawTransaction(utxo.txid);
+        psbt.addInput({
+          hash: utxo.txid,
+          index: utxo.vout,
+          nonWitnessUtxo: Buffer.from(txHex, "hex")
+        });
+      }
+      inputSum += utxo.value;
+      const estimatedSize = provider.estimateTxSize(psbt.inputCount, outputs.length);
+      const estimatedFee = Math.ceil(effectiveFeeRate * estimatedSize);
+      if (inputSum >= outputSum + estimatedFee + DUST_THRESHOLD) {
+        break;
+      }
+    }
+    for (const output of outputs) {
+      psbt.addOutput({
+        address: output.address,
+        value: output.value
+      });
+    }
+    const sizeWithChange = provider.estimateTxSize(psbt.inputCount, outputs.length + 1);
+    const sizeWithoutChange = provider.estimateTxSize(psbt.inputCount, outputs.length);
+    const feeWithChange = Math.ceil(effectiveFeeRate * sizeWithChange);
+    const feeWithoutChange = Math.ceil(effectiveFeeRate * sizeWithoutChange);
+    let change = inputSum - outputSum - feeWithChange;
+    if (change < 0) {
+      const confirmedCount = utxos.filter((u) => u.status.confirmed).length;
+      const unconfirmedCount = utxos.length - confirmedCount;
+      const hint = unconfirmedCount > 0 ? ` (${unconfirmedCount} unconfirmed UTXO(s) skipped \u2014 wait for confirmation)` : "";
+      throw new Error(`Insufficient funds. Need ${outputSum + feeWithChange} satoshis, have ${inputSum}${hint}`);
+    }
+    if (change > DUST_THRESHOLD) {
+      psbt.addOutput({
+        address: changeAddress,
+        value: change
+      });
+    } else {
+      const finalFee = feeWithoutChange;
+      change = inputSum - outputSum - finalFee;
+      if (change < 0) {
+        throw new Error(`Insufficient funds after dust handling. Need ${outputSum + finalFee}`);
+      }
+    }
+    return psbt;
+  }
+  /**
+   * Deposit operation - transfer BTC to the asset manager
+   */
+  static async deposit(token, amount, data, provider, raw, accessToken = "") {
+    try {
+      const walletAddress = await provider.walletProvider.getWalletAddress();
+      const returnRawTx = (psbtBase64) => ({
+        from: walletAddress,
+        to: provider.chainConfig.addresses.assetManager,
+        value: amount,
+        data: psbtBase64
+      });
+      if (provider.walletMode === "TRADING") {
+        const tokenId = Object.values(provider.chainConfig.supportedTokens).find((t) => t.address === token)?.address;
+        if (!tokenId) {
+          throw new Error(`Unsupported token: ${token}`);
+        }
+        data = data.startsWith("0x") ? data.slice(2) : data;
+        data = data.length === 64 ? data : viem.keccak256(`0x${data}`).slice(2);
+        accessToken = accessToken || provider.radfiAccessToken;
+        const withdrawTx = await provider.radfi.createWithdrawTransaction(
+          {
+            token: tokenId,
+            amount,
+            recipient: provider.chainConfig.addresses.assetManager,
+            userAddress: walletAddress,
+            data
+          },
+          accessToken
+        );
+        if (raw || isBitcoinRawSpokeProvider(provider)) {
+          return returnRawTx(withdrawTx.base64Psbt);
+        }
+        const signedTx = await provider.walletProvider.signTransaction(withdrawTx.base64Psbt, false);
+        const signedBase64Tx = normalizePsbtToBase64(signedTx);
+        return await provider.radfi.requestRadfiSignature(
+          {
+            userAddress: walletAddress,
+            signedBase64Tx
+          },
+          accessToken
+        );
+      }
+      const utxos = await provider.fetchUTXOs(walletAddress);
+      if (!utxos?.length) {
+        throw new Error("No UTXOs available for deposit");
+      }
+      const depositPsbt = await _BitcoinBaseSpokeProvider.buildDepositPsbt(
+        walletAddress,
+        token,
+        amount,
+        data,
+        utxos,
+        provider
+      );
+      if (raw || isBitcoinRawSpokeProvider(provider)) {
+        return returnRawTx(depositPsbt.toBase64());
+      }
+      return await provider.signAndBroadcastTransaction(depositPsbt);
+    } catch (error) {
+      console.error("Error during deposit:", error);
+      throw error;
+    }
+  }
+  /**
+   * Build deposit PSBT with embedded cross-chain data
+   */
+  static async buildDepositPsbt(walletAddress, token, amount, data, utxos, provider) {
+    const assetManagerAddress = provider.chainConfig.addresses.assetManager;
+    if (token.toLocaleLowerCase() === "btc") {
+      const outputs = [
+        {
+          address: assetManagerAddress,
+          value: Number(amount)
+        }
+      ];
+      const psbt = await _BitcoinBaseSpokeProvider.buildBitcoinTransaction(utxos, outputs, walletAddress, provider);
+      const OP_RADFI_SODAX_DATA = 49;
+      const payload = Buffer.concat([Buffer.from([OP_RADFI_SODAX_DATA]), Buffer.from(data.slice(2), "hex")]);
+      const OP_RETURN = bitcoin__namespace.opcodes.OP_RETURN;
+      const OP_12 = bitcoin__namespace.opcodes.OP_12;
+      if (OP_RETURN === void 0 || OP_12 === void 0) {
+        throw new Error("bitcoinjs-lib opcodes OP_RETURN or OP_12 are undefined");
+      }
+      const script2 = bitcoin__namespace.script.compile([OP_RETURN, OP_12, payload]);
+      psbt.addOutput({
+        script: script2,
+        value: 0
+      });
+      return psbt;
+    }
+    throw new Error(`Non-BTC token deposits not yet implemented (token: ${token})`);
+  }
+  /**
+   * Fetch UTXOs for an address
+   */
+  async fetchUTXOs(address) {
+    const response = await fetch(`${this.rpcUrl}/address/${address}/utxo`);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch UTXOs: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  /**
+   * Fetch raw transaction hex
+   */
+  async fetchRawTransaction(txid) {
+    const response = await fetch(`${this.rpcUrl}/tx/${txid}/hex`);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch transaction: ${response.statusText}`);
+    }
+    return await response.text();
+  }
+  /**
+   * Estimate transaction size in vbytes
+   */
+  estimateTxSize(inputCount, outputCount) {
+    return Math.ceil(10.5 + 44 + inputCount * 68 + outputCount * 31);
+  }
+  getAddressType(address) {
+    return detectBitcoinAddressType(address);
+  }
+  encodePayloadToBytes(payload) {
+    const ordered = {
+      src_address: payload.src_address.toLowerCase(),
+      data: payload.data.toLowerCase(),
+      src_chain_id: payload.src_chain_id,
+      dst_chain_id: payload.dst_chain_id,
+      wallet_used: payload.wallet_used,
+      timestamp: payload.timestamp,
+      address_type: payload.address_type
+    };
+    const json = JSON.stringify(ordered);
+    return json;
+  }
+  static async encodeWithdrawalData(dstChainId, data, provider, raw) {
+    let srcAddress = await provider.walletProvider.getWalletAddress();
+    const addressType = provider.getAddressType(srcAddress);
+    if (provider.walletMode === "TRADING") {
+      srcAddress = await provider.radfi.getTradingWallet(srcAddress).then((res) => res.tradingAddress).catch(() => srcAddress);
+    }
+    const payload = {
+      src_address: srcAddress,
+      data,
+      src_chain_id: Number(getIntentRelayChainId(provider.chainConfig.chain.id)),
+      dst_chain_id: Number(getIntentRelayChainId(dstChainId)),
+      wallet_used: provider.walletMode,
+      timestamp: Date.now(),
+      address_type: addressType
+    };
+    const orderedPayload = provider.encodePayloadToBytes(payload);
+    const onDemandWithdraw = {
+      payload_hex: Buffer.from(orderedPayload).toString("hex"),
+      signature: void 0
+    };
+    if (raw || isBitcoinRawSpokeProvider(provider)) {
+      return JSON.stringify(onDemandWithdraw);
+    }
+    const signature = await provider.walletProvider.signEcdsaMessage(orderedPayload);
+    onDemandWithdraw.signature = signature;
+    return JSON.stringify(onDemandWithdraw);
+  }
+};
+var BitcoinRawSpokeProvider = class extends BitcoinBaseSpokeProvider {
+  walletProvider;
+  raw = true;
+  constructor(walletAddress, publicKey, chainConfig, radfiConfig, walletMode = "USER", rpcUrl) {
+    super(chainConfig, radfiConfig, walletMode, rpcUrl);
+    this.walletProvider = {
+      getWalletAddress: async () => walletAddress,
+      getPublicKey: async () => publicKey
+    };
+  }
+};
+var BitcoinSpokeProvider = class extends BitcoinBaseSpokeProvider {
+  walletProvider;
+  constructor(walletProvider, chainConfig, radfiConfig, walletMode = "USER", rpcUrl) {
+    super(chainConfig, radfiConfig, walletMode, rpcUrl);
+    this.walletProvider = walletProvider;
+  }
+  /**
+   * Authenticate with Radfi: BIP322-sign a login message, then call the Radfi API.
+   * Returns accessToken, refreshToken, and tradingAddress.
+   */
+  async authenticateWithWallet(cachedPublicKey) {
+    const address = await this.walletProvider.getWalletAddress();
+    let publicKey = cachedPublicKey;
+    if (!publicKey) {
+      if (!this.walletProvider.getPublicKey) {
+        throw new Error("Wallet provider does not support getPublicKey");
+      }
+      publicKey = await this.walletProvider.getPublicKey();
+    }
+    if (!publicKey) {
+      throw new Error("Failed to retrieve public key from wallet. Please unlock your wallet and try again.");
+    }
+    const message = `Login to Radfi via Sodax: ${Date.now()}`;
+    const signature = await this.walletProvider.signBip322Message(message);
+    const result = await this.radfi.authenticate({ message, signature, address, publicKey });
+    this.setRadfiAccessToken(result.accessToken);
+    return { ...result, publicKey };
+  }
+  /**
+   * Ensure a valid Radfi access token is set on this provider.
+   * No-op if a token is already present.
+   */
+  async ensureRadfiAccessToken() {
+    if (this.radfiAccessToken) return;
+    await this.authenticateWithWallet();
+  }
+  /**
+   * Sign and broadcast a Bitcoin transaction
+   */
+  async signAndBroadcastTransaction(psbt) {
+    const psbtBase64 = typeof psbt === "string" ? psbt : psbt.toBase64();
+    const signedPsbtHex = await this.walletProvider.signTransaction(psbtBase64);
+    const txHash = await this.broadcastTransaction(signedPsbtHex);
+    return txHash;
+  }
+  /**
+   * Broadcast a signed transaction
+   */
+  async broadcastTransaction(txHex) {
+    const response = await fetch(`${this.rpcUrl}/tx`, {
+      method: "POST",
+      body: txHex
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Failed to broadcast transaction: ${errorText}`);
+    }
+    return await response.text();
+  }
+};
+
+// src/shared/services/spoke/BitcoinSpokeService.ts
+var BitcoinSpokeService = class _BitcoinSpokeService {
+  constructor() {
+  }
+  /**
+   * Estimate transaction fee for a Bitcoin transaction
+   *
+   * @param {Hex} rawTx - The raw transaction parameters
+   * @param {BitcoinSpokeProviderType} spokeProvider - The Bitcoin spoke provider
+   * @returns {Promise<bigint>} Estimated fee in satoshis
+   */
+  static async estimateGas(rawTx, spokeProvider) {
+    const txBytes = Buffer.from(rawTx, "hex");
+    const vsize = Math.ceil(txBytes.length);
+    const feeRate = await spokeProvider.getFeeEstimate();
+    const feeRateBigInt = typeof feeRate === "bigint" ? feeRate : BigInt(Math.ceil(feeRate));
+    return BigInt(vsize) * feeRateBigInt;
+  }
+  /**
+   * Deposit tokens to the spoke chain and bridge to hub
+   *
+   * @param {BitcoinSpokeDepositParams} params - Deposit parameters
+   * @param {BitcoinSpokeProviderType} spokeProvider - The Bitcoin spoke provider
+   * @param {EvmHubProvider} EvmHubProvider - The hub chain provider
+   * @param {boolean} raw - Whether to return raw PSBT or transaction hash
+   * @returns {Promise<TxReturnType<BitcoinSpokeProviderType, R>>} Transaction hash or raw PSBT
+   */
+  static async deposit(params, spokeProvider, raw) {
+    return _BitcoinSpokeService.transfer(
+      {
+        token: params.token,
+        amount: params.amount,
+        data: params.data ?? "0x",
+        accessToken: params.accessToken
+      },
+      spokeProvider,
+      raw
+    );
+  }
+  /**
+   * Get the balance of deposited tokens in the asset manager
+   *
+   * @param {string} token - Token identifier ('BTC' for native Bitcoin)
+   * @param {BitcoinSpokeProviderType} spokeProvider - The Bitcoin spoke provider
+   * @returns {Promise<bigint>} Balance in satoshis
+   */
+  static async getDeposit(token, spokeProvider) {
+    const assetManagerAddress = spokeProvider.chainConfig.addresses.assetManager;
+    const utxos = await spokeProvider.fetchUTXOs(assetManagerAddress);
+    const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
+    return BigInt(totalBalance);
+  }
+  /**
+   * Generate simulation parameters for deposit
+   *
+   * @param {BitcoinSpokeDepositParams} params - Deposit parameters
+   * @param {BitcoinSpokeProviderType} spokeProvider - The Bitcoin spoke provider
+   * @param {EvmHubProvider} EvmHubProvider - The hub chain provider
+   * @returns {Promise<DepositSimulationParams>} Simulation parameters
+   */
+  static async getSimulateDepositParams(params, spokeProvider, EvmHubProvider2) {
+    const to = params.to ?? await EvmWalletAbstraction.getUserHubWalletAddress(
+      spokeProvider.chainConfig.chain.id,
+      encodeAddress(spokeProvider.chainConfig.chain.id, params.from),
+      EvmHubProvider2
+    );
+    const tokenEntry = Object.values(spokeProvider.chainConfig.supportedTokens).find((t) => t.address === params.token);
+    const token = tokenEntry?.address ?? params.token;
+    return {
+      spokeChainID: spokeProvider.chainConfig.chain.id,
+      token: encodeAddress(spokeProvider.chainConfig.chain.id, token),
+      from: encodeAddress(spokeProvider.chainConfig.chain.id, params.from),
+      to,
+      amount: params.amount,
+      data: params.data,
+      srcAddress: encodeAddress(spokeProvider.chainConfig.chain.id, spokeProvider.chainConfig.addresses.assetManager)
+    };
+  }
+  /**
+   * Fund the Radfi trading wallet by sending BTC from the user's personal wallet
+   *
+   * @param {bigint} amount - Amount in satoshis to send
+   * @param {BitcoinSpokeProvider} spokeProvider - The Bitcoin spoke provider (must have signing capability)
+   * @returns {Promise<string>} Transaction ID of the funding transaction
+   */
+  static async fundTradingWallet(amount, spokeProvider) {
+    const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+    const { tradingAddress } = await spokeProvider.radfi.getTradingWallet(walletAddress);
+    return spokeProvider.walletProvider.sendBitcoin(tradingAddress, amount);
+  }
+  /**
+   * Call a contract on the hub chain from Bitcoin spoke
+   *
+   * @param {HubAddress} from - The hub wallet address
+   * @param {Hex} payload - The payload to send
+   * @param {BitcoinSpokeProviderType} spokeProvider - The Bitcoin spoke provider
+   * @param {EvmHubProvider} EvmHubProvider - The hub chain provider
+   * @param {boolean} raw - Whether to return raw PSBT or transaction hash
+   * @returns {Promise<TxReturnType<BitcoinSpokeProviderType, R>>} Stringified JSON for payload and signature
+   */
+  static async callWallet(from, payload, spokeProvider, EvmHubProvider2, raw) {
+    return _BitcoinSpokeService.call(EvmHubProvider2.chainConfig.chain.id, from, payload, spokeProvider, raw);
+  }
+  /**
+   * Transfer tokens to the hub chain
+   *
+   * @param {BitcoinTransferToHubParams} params - Transfer parameters
+   * @param {BitcoinSpokeProviderType} spokeProvider - The Bitcoin spoke provider
+   * @param {boolean} raw - Whether to return raw PSBT or transaction hash
+   * @returns {Promise<TxReturnType<BitcoinSpokeProviderType, R>>} Transaction hash or raw PSBT
+   */
+  static async transfer({ token, amount, data = "0x", accessToken }, spokeProvider, raw) {
+    return await BitcoinBaseSpokeProvider.deposit(token, amount, data, spokeProvider, raw, accessToken);
+  }
+  /**
+   * Send a message to the hub chain
+   *
+   * @param {HubChainId} dstChainId - Destination chain ID
+   * @param {HubAddress} dstAddress - Destination address on hub
+   * @param {Hex} payload - Message payload
+   * @param {BitcoinSpokeProviderType} spokeProvider - The Bitcoin spoke provider
+   * @param {boolean} raw - Whether to return raw PSBT or transaction hash
+   * @returns {Promise<TxReturnType<BitcoinSpokeProviderType, R>>} Transaction hash or raw PSBT
+   */
+  static async call(dstChainId, dstAddress, payload, spokeProvider, raw) {
+    return await BitcoinBaseSpokeProvider.encodeWithdrawalData(
+      dstChainId,
+      payload,
+      spokeProvider,
+      raw
+    );
+  }
+};
 var NearSpokeService = class _NearSpokeService {
   constructor() {
   }
@@ -21564,6 +22355,14 @@ var SpokeService = class _SpokeService {
         raw
       );
     }
+    if (isBitcoinSpokeProviderType(spokeProvider)) {
+      await _SpokeService.verifyDepositSimulation(params, spokeProvider, hubProvider, skipSimulation);
+      return BitcoinSpokeService.deposit(
+        params,
+        spokeProvider,
+        raw
+      );
+    }
     if (isNearSpokeProviderType(spokeProvider)) {
       await _SpokeService.verifyDepositSimulation(params, spokeProvider, hubProvider, skipSimulation);
       return NearSpokeService.deposit(
@@ -21618,6 +22417,13 @@ var SpokeService = class _SpokeService {
         hubProvider
       );
     }
+    if (isBitcoinSpokeProviderType(spokeProvider)) {
+      return BitcoinSpokeService.getSimulateDepositParams(
+        params,
+        spokeProvider,
+        hubProvider
+      );
+    }
     if (isNearSpokeProviderType(spokeProvider)) {
       return NearSpokeService.getSimulateDepositParams(
         params,
@@ -21664,6 +22470,9 @@ var SpokeService = class _SpokeService {
     if (isSonicSpokeProviderType(spokeProvider)) {
       return SonicSpokeService.getDeposit(token, spokeProvider);
     }
+    if (isBitcoinSpokeProviderType(spokeProvider)) {
+      return BitcoinSpokeService.getDeposit(token, spokeProvider);
+    }
     if (isNearSpokeProviderType(spokeProvider)) {
       return NearSpokeService.getDeposit(token, spokeProvider);
     }
@@ -21681,15 +22490,24 @@ var SpokeService = class _SpokeService {
     if (isSonicSpokeProviderType(spokeProvider)) {
       return await SonicSpokeService.callWallet(payload, spokeProvider, raw);
     }
+    let srcAddress = encodeAddress(
+      spokeProvider.chainConfig.chain.id,
+      await spokeProvider.walletProvider.getWalletAddress()
+    );
+    if (isBitcoinSpokeProvider(spokeProvider)) {
+      if (spokeProvider.walletMode === "TRADING") {
+        const tradingWalletAddress = await spokeProvider.radfi.getTradingWallet(
+          await spokeProvider.walletProvider.getWalletAddress()
+        );
+        srcAddress = encodeAddress(spokeProvider.chainConfig.chain.id, tradingWalletAddress.tradingAddress);
+      }
+    }
     if (!skipSimulation) {
       const result = await _SpokeService.simulateRecvMessage(
         {
           target: from,
           srcChainId: getIntentRelayChainId(spokeProvider.chainConfig.chain.id),
-          srcAddress: encodeAddress(
-            spokeProvider.chainConfig.chain.id,
-            await spokeProvider.walletProvider.getWalletAddress()
-          ),
+          srcAddress,
           payload
         },
         hubProvider
@@ -21740,6 +22558,16 @@ var SpokeService = class _SpokeService {
         raw
       );
     }
+    if (isBitcoinSpokeProviderType(spokeProvider)) {
+      await _SpokeService.verifySimulation(from, payload, spokeProvider, hubProvider, skipSimulation);
+      return await BitcoinSpokeService.callWallet(
+        from,
+        payload,
+        spokeProvider,
+        hubProvider,
+        raw
+      );
+    }
     if (isNearSpokeProviderType(spokeProvider)) {
       await _SpokeService.verifySimulation(from, payload, spokeProvider, hubProvider, skipSimulation);
       return await NearSpokeService.callWallet(from, payload, spokeProvider, hubProvider, raw);
@@ -21748,14 +22576,26 @@ var SpokeService = class _SpokeService {
   }
   static async verifySimulation(from, payload, spokeProvider, hubProvider, skipSimulation) {
     if (!skipSimulation) {
+      let srcAddress = encodeAddress(
+        spokeProvider.chainConfig.chain.id,
+        await spokeProvider.walletProvider.getWalletAddress()
+      );
+      if (isBitcoinSpokeProvider(spokeProvider)) {
+        if (spokeProvider.walletMode === "TRADING") {
+          const tradingWalletAddress = await spokeProvider.radfi.getTradingWallet(
+            await spokeProvider.walletProvider.getWalletAddress()
+          );
+          srcAddress = encodeAddress(
+            spokeProvider.chainConfig.chain.id,
+            tradingWalletAddress.tradingAddress
+          );
+        }
+      }
       const result = await _SpokeService.simulateRecvMessage(
         {
           target: from,
           srcChainId: getIntentRelayChainId(spokeProvider.chainConfig.chain.id),
-          srcAddress: encodeAddress(
-            spokeProvider.chainConfig.chain.id,
-            await spokeProvider.walletProvider.getWalletAddress()
-          ),
+          srcAddress,
           payload
         },
         hubProvider
@@ -22189,7 +23029,7 @@ var SwapService = class {
       let dstIntentTxHash;
       if (spokeProvider.chainConfig.chain.id !== this.hubProvider.chainConfig.chain.id) {
         const intentRelayChainId = getIntentRelayChainId(params.srcChain).toString();
-        const submitPayload = params.srcChain === SOLANA_MAINNET_CHAIN_ID && data ? {
+        const submitPayload = (params.srcChain === SOLANA_MAINNET_CHAIN_ID || params.srcChain === BITCOIN_MAINNET_CHAIN_ID) && data ? {
           action: "submit",
           params: {
             chain_id: intentRelayChainId,
@@ -22514,17 +23354,51 @@ var SwapService = class {
       this.configService.isValidSpokeChainId(params.dstChain),
       `Invalid spoke chain (params.dstChain): ${params.dstChain}`
     );
+    if (params.dstChain === BITCOIN_MAINNET_CHAIN_ID && params.outputToken === "BTC") {
+      invariant6__default.default(
+        params.minOutputAmount >= 546n,
+        `Invalid minOutputAmount (params.minOutputAmount): ${params.minOutputAmount}`
+      );
+    }
     try {
-      const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      console.log("[SwapService.createIntent] start", {
+        srcChain: params.srcChain,
+        dstChain: params.dstChain,
+        inputToken: params.inputToken,
+        inputAmount: params.inputAmount.toString()
+      });
+      let walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      console.log("[SwapService.createIntent] walletAddress", walletAddress, "srcAddress", params.srcAddress);
       invariant6__default.default(
         params.srcAddress.toLowerCase() === walletAddress.toLowerCase(),
         "srcAddress must be the same as wallet address"
       );
+      if (isBitcoinSpokeProvider(spokeProvider)) {
+        console.log(
+          "[SwapService.createIntent] Bitcoin detected, walletMode:",
+          spokeProvider.walletMode,
+          "hasToken:",
+          !!spokeProvider.radfiAccessToken
+        );
+        await spokeProvider.ensureRadfiAccessToken();
+        console.log(
+          "[SwapService.createIntent] ensureRadfiAccessToken done, hasToken:",
+          !!spokeProvider.radfiAccessToken
+        );
+        if (spokeProvider.walletMode === "TRADING") {
+          const tradingWalletAddress = await spokeProvider.radfi.getTradingWallet(
+            await spokeProvider.walletProvider.getWalletAddress()
+          );
+          console.log("[SwapService.createIntent] tradingWalletAddress", tradingWalletAddress);
+          walletAddress = tradingWalletAddress.tradingAddress;
+        }
+      }
       const creatorHubWalletAddress = await deriveUserWalletAddress(
         this.hubProvider,
         spokeProvider.chainConfig.chain.id,
         walletAddress
       );
+      console.log("[SwapService.createIntent] creatorHubWalletAddress", creatorHubWalletAddress);
       if (spokeProvider.chainConfig.chain.id === this.hubProvider.chainConfig.chain.id && isSonicSpokeProviderType(spokeProvider)) {
         const [txResult, intent, feeAmount, data] = await SonicSpokeService.createSwapIntent(
           params,
@@ -22555,6 +23429,11 @@ var SwapService = class {
           this.configService,
           fee
         );
+        console.log("[SwapService.createIntent] intent data constructed", {
+          data,
+          intentId: intent.intentId?.toString()
+        });
+        console.log("[SwapService.createIntent] calling SpokeService.deposit...");
         const txResult = await SpokeService.deposit(
           {
             from: walletAddress,
@@ -22568,12 +23447,14 @@ var SwapService = class {
           raw,
           skipSimulation
         );
+        console.log("[SwapService.createIntent] SpokeService.deposit done, txResult:", txResult);
         return {
           ok: true,
           value: [txResult, { ...intent, feeAmount }, data]
         };
       }
     } catch (error) {
+      console.error("[SwapService.createIntent] FAILED", error);
       return {
         ok: false,
         error: {
@@ -25632,9 +26513,15 @@ function isNearSpokeProvider(value) {
 function isStellarSpokeProviderType(value) {
   return typeof value === "object" && value !== null && (isStellarSpokeProvider(value) || isStellarRawSpokeProvider(value));
 }
+function isBitcoinSpokeProviderType(value) {
+  return typeof value === "object" && value !== null && (isBitcoinSpokeProvider(value) || isBitcoinRawSpokeProvider(value));
+}
 function isStellarSpokeProvider(value) {
   return typeof value === "object" && value !== null && value instanceof StellarSpokeProvider && !("raw" in value) && value.chainConfig.chain.type === "STELLAR";
 }
+function isBitcoinSpokeProvider(value) {
+  return typeof value === "object" && value !== null && value instanceof BitcoinSpokeProvider && !("raw" in value) && value.chainConfig.chain.type === "BITCOIN";
+}
 function isNearSpokeProviderType(value) {
   return typeof value === "object" && value !== null && (isNearSpokeProvider(value) || isNearRawSpokeProvider(value));
 }
@@ -25731,6 +26618,9 @@ function isSolanaRawSpokeProvider(value) {
 function isStellarRawSpokeProvider(value) {
   return isRawSpokeProvider(value) && value.chainConfig.chain.type === "STELLAR";
 }
+function isBitcoinRawSpokeProvider(value) {
+  return isRawSpokeProvider(value) && value.chainConfig.chain.type === "BITCOIN";
+}
 function isIconRawSpokeProvider(value) {
   return isRawSpokeProvider(value) && value.chainConfig.chain.type === "ICON";
 }
@@ -25764,6 +26654,26 @@ function isSolanaRawSpokeProviderConfig(value) {
 function isNearRawSpokeProviderConfig(value) {
   return typeof value === "object" && value !== null && "walletAddress" in value && "chainConfig" in value && value.chainConfig.chain.type === "NEAR";
 }
+function isSubmitSwapTxResponse(value) {
+  return typeof value === "object" && value !== null && typeof value.success === "boolean" && typeof value.message === "string";
+}
+function isSubmitSwapTxStatusResponse(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  if (typeof obj.success !== "boolean") return false;
+  if (typeof obj.data !== "object" || obj.data === null) return false;
+  const data = obj.data;
+  if (typeof data.txHash !== "string") return false;
+  if (typeof data.srcChainId !== "string") return false;
+  if (typeof data.status !== "string") return false;
+  if (typeof data.failedAttempts !== "number") return false;
+  if (data.result !== void 0) {
+    if (typeof data.result !== "object" || data.result === null) return false;
+    const result = data.result;
+    if (typeof result.dstIntentTxHash !== "string") return false;
+  }
+  return true;
+}
 async function retry(action, retryCount = DEFAULT_MAX_RETRY, delayMs = DEFAULT_RETRY_DELAY_MS) {
   do {
     try {
@@ -25839,8 +26749,6 @@ function encodeAddress(spokeChainId, address) {
     case "0xa4b1.arbitrum":
     case "sonic":
       return address;
-    case "injective-1":
-      return viem.toHex(Buffer.from(address, "utf-8"));
     case "0x1.icon":
       return viem.toHex(Buffer.from(address.replace("cx", "01").replace("hx", "00") ?? "f8", "hex"));
     case "sui":
@@ -25849,7 +26757,9 @@ function encodeAddress(spokeChainId, address) {
       return viem.toHex(Buffer.from(new web3_js.PublicKey(address).toBytes()));
     case "stellar":
       return `0x${stellarSdk.Address.fromString(address).toScVal().toXDR("hex")}`;
+    case "bitcoin":
     case "near":
+    case "injective-1":
       return viem.toHex(Buffer.from(address, "utf-8"));
     default:
       return address;
@@ -25975,10 +26885,11 @@ var BackendApiService = class {
    * @returns Promise<T>
    */
   async makeRequest(endpoint, config) {
-    const url = `${this.baseURL}${endpoint}`;
+    const url = config.baseURL ? `${config.baseURL}${endpoint}` : `${this.baseURL}${endpoint}`;
     const headers = { ...this.defaultHeaders, ...config.headers };
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const timeout = config.timeout ?? this.timeout;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
       const response = await fetch(url, {
         method: config.method,
@@ -25997,7 +26908,7 @@ var BackendApiService = class {
       clearTimeout(timeoutId);
       if (error instanceof Error) {
         if (error.name === "AbortError") {
-          throw new Error(`Request timeout after ${this.timeout}ms`);
+          throw new Error(`Request timeout after ${timeout}ms`);
         }
         console.error("[BackendApiService] Request error:", error.message);
         throw error;
@@ -26013,16 +26924,50 @@ var BackendApiService = class {
    * @param txHash - The intent created transaction hash from the hub chain
    * @returns Promise<IntentResponse>
    */
-  async getIntentByTxHash(txHash) {
-    return this.makeRequest(`/intent/tx/${txHash}`, { method: "GET" });
+  async getIntentByTxHash(txHash, config) {
+    return this.makeRequest(`/intent/tx/${txHash}`, { ...config, method: "GET" });
   }
   /**
    * Get intent details by intent hash
    * @param intentHash - Intent hash
    * @returns Promise<IntentResponse>
    */
-  async getIntentByHash(intentHash) {
-    return this.makeRequest(`/intent/${intentHash}`, { method: "GET" });
+  async getIntentByHash(intentHash, config) {
+    return this.makeRequest(`/intent/${intentHash}`, { ...config, method: "GET" });
+  }
+  // Swap submit-tx endpoints
+  /**
+   * Submit a swap transaction to be processed (relay, post execution to solver, etc.)
+   * @param params - Swap transaction submission data
+   * @returns Promise<SubmitSwapTxResponse>
+   */
+  async submitSwapTx(params, config) {
+    const data = await this.makeRequest("/swaps/submit-tx", {
+      ...config,
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+    if (!isSubmitSwapTxResponse(data)) {
+      throw new Error("Invalid submitSwapTx response: unexpected response shape");
+    }
+    return data;
+  }
+  /**
+   * Get the processing status of a submitted swap transaction
+   * @param params - Query parameters containing txHash and optional srcChainId
+   * @returns Promise<SubmitSwapTxStatusResponse>
+   */
+  async getSubmitSwapTxStatus(params, config) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("txHash", params.txHash);
+    if (params.srcChainId) queryParams.append("srcChainId", params.srcChainId);
+    const queryString = queryParams.toString();
+    const endpoint = `/swaps/submit-tx/status?${queryString}`;
+    const data = await this.makeRequest(endpoint, { ...config, method: "GET" });
+    if (!isSubmitSwapTxStatusResponse(data)) {
+      throw new Error("Invalid submitSwapTxStatus response: unexpected response shape");
+    }
+    return data;
   }
   // Solver endpoints
   /**
@@ -26030,13 +26975,13 @@ var BackendApiService = class {
    * @param params - Object containing offset and limit parameters for pagination
    * @returns Promise<OrderbookResponse>
    */
-  async getOrderbook(params) {
+  async getOrderbook(params, config) {
     const queryParams = new URLSearchParams();
     queryParams.append("offset", params.offset);
     queryParams.append("limit", params.limit);
     const queryString = queryParams.toString();
     const endpoint = `/solver/orderbook?${queryString}`;
-    return this.makeRequest(endpoint, { method: "GET" });
+    return this.makeRequest(endpoint, { ...config, method: "GET" });
   }
   /**
    * Get all intents created by a specific user address with optional filters.
@@ -26050,7 +26995,7 @@ var BackendApiService = class {
    *
    * @returns {Promise<UserIntentsResponse>} Promise resolving to an array of intent responses for the user.
    */
-  async getUserIntents(params) {
+  async getUserIntents(params, config) {
     const { userAddress, startDate, endDate, limit, offset } = params;
     const queryParams = new URLSearchParams();
     if (startDate) queryParams.append("startDate", new Date(startDate).toISOString());
@@ -26059,7 +27004,7 @@ var BackendApiService = class {
     if (offset) queryParams.append("offset", offset);
     const queryString = queryParams.toString();
     const endpoint = queryString.length > 0 ? `/intent/user/${userAddress}?${queryString}` : `/intent/user/${userAddress}`;
-    return this.makeRequest(endpoint, { method: "GET" });
+    return this.makeRequest(endpoint, { ...config, method: "GET" });
   }
   // Money Market endpoints
   /**
@@ -26067,23 +27012,23 @@ var BackendApiService = class {
    * @param userAddress - User's wallet address
    * @returns Promise<MoneyMarketPosition>
    */
-  async getMoneyMarketPosition(userAddress) {
-    return this.makeRequest(`/moneymarket/position/${userAddress}`, { method: "GET" });
+  async getMoneyMarketPosition(userAddress, config) {
+    return this.makeRequest(`/moneymarket/position/${userAddress}`, { ...config, method: "GET" });
   }
   /**
    * Get all money market assets
    * @returns Promise<MoneyMarketAsset[]>
    */
-  async getAllMoneyMarketAssets() {
-    return this.makeRequest("/moneymarket/asset/all", { method: "GET" });
+  async getAllMoneyMarketAssets(config) {
+    return this.makeRequest("/moneymarket/asset/all", { ...config, method: "GET" });
   }
   /**
    * Get specific money market asset details
    * @param reserveAddress - Reserve contract address
    * @returns Promise<MoneyMarketAsset>
    */
-  async getMoneyMarketAsset(reserveAddress) {
-    return this.makeRequest(`/moneymarket/asset/${reserveAddress}`, { method: "GET" });
+  async getMoneyMarketAsset(reserveAddress, config) {
+    return this.makeRequest(`/moneymarket/asset/${reserveAddress}`, { ...config, method: "GET" });
   }
   /**
    * Get borrowers for a specific money market asset
@@ -26091,13 +27036,13 @@ var BackendApiService = class {
    * @param params - Object containing offset and limit parameters for pagination
    * @returns Promise<MoneyMarketAssetBorrowers>
    */
-  async getMoneyMarketAssetBorrowers(reserveAddress, params) {
+  async getMoneyMarketAssetBorrowers(reserveAddress, params, config) {
     const queryParams = new URLSearchParams();
     queryParams.append("offset", params.offset);
     queryParams.append("limit", params.limit);
     const queryString = queryParams.toString();
     const endpoint = `/moneymarket/asset/${reserveAddress}/borrowers?${queryString}`;
-    return this.makeRequest(endpoint, { method: "GET" });
+    return this.makeRequest(endpoint, { ...config, method: "GET" });
   }
   /**
    * Get suppliers for a specific money market asset
@@ -26105,69 +27050,76 @@ var BackendApiService = class {
    * @param params - Object containing offset and limit parameters for pagination
    * @returns Promise<MoneyMarketAssetSuppliers>
    */
-  async getMoneyMarketAssetSuppliers(reserveAddress, params) {
+  async getMoneyMarketAssetSuppliers(reserveAddress, params, config) {
     const queryParams = new URLSearchParams();
     queryParams.append("offset", params.offset);
     queryParams.append("limit", params.limit);
     const queryString = queryParams.toString();
     const endpoint = `/moneymarket/asset/${reserveAddress}/suppliers?${queryString}`;
-    return this.makeRequest(endpoint, { method: "GET" });
+    return this.makeRequest(endpoint, { ...config, method: "GET" });
   }
   /**
    * Get all money market borrowers
    * @param params - Object containing offset and limit parameters for pagination
    * @returns Promise<MoneyMarketBorrowers>
    */
-  async getAllMoneyMarketBorrowers(params) {
+  async getAllMoneyMarketBorrowers(params, config) {
     const queryParams = new URLSearchParams();
     queryParams.append("offset", params.offset);
     queryParams.append("limit", params.limit);
     const queryString = queryParams.toString();
     const endpoint = `/moneymarket/borrowers?${queryString}`;
-    return this.makeRequest(endpoint, { method: "GET" });
+    return this.makeRequest(endpoint, { ...config, method: "GET" });
   }
   /**
    * Get all supported config
    * @returns Promise<GetAllConfigApiResponse>
    */
-  async getAllConfig() {
-    return this.makeRequest("/config/all", { method: "GET" });
+  async getAllConfig(config) {
+    return this.makeRequest("/config/all", { ...config, method: "GET" });
   }
   /**
    * Get all supported spoke chains
    * @returns Promise<GetChainsApiResponse>
    */
-  async getChains() {
-    return this.makeRequest("/config/spoke/chains", { method: "GET" });
+  async getChains(config) {
+    return this.makeRequest("/config/spoke/chains", { ...config, method: "GET" });
   }
   /**
    * Get all supported swap tokens
    * @returns Promise<GetSwapTokensApiResponse>
    */
-  async getSwapTokens() {
-    return this.makeRequest("/config/swap/tokens", { method: "GET" });
+  async getSwapTokens(config) {
+    return this.makeRequest("/config/swap/tokens", { ...config, method: "GET" });
   }
   /**
    * Get supported swap tokens for a specific spoke chain
    * @param chainId - Spoke chain id
    * @returns Promise<GetSwapTokensByChainIdApiResponse>
    */
-  async getSwapTokensByChainId(chainId) {
-    return this.makeRequest(`/config/swap/${chainId}/tokens`, { method: "GET" });
+  async getSwapTokensByChainId(chainId, config) {
+    return this.makeRequest(`/config/swap/${chainId}/tokens`, {
+      ...config,
+      method: "GET"
+    });
   }
   /**
    * Get all supported money market tokens
    * @returns Promise<GetMoneyMarketTokensApiResponse>
    */
-  async getMoneyMarketTokens() {
-    return this.makeRequest("/config/money-market/tokens", { method: "GET" });
+  async getMoneyMarketTokens(config) {
+    return this.makeRequest("/config/money-market/tokens", {
+      ...config,
+      method: "GET"
+    });
   }
   /**
    * Get all supported money market tokens
    * @returns Promise<GetMoneyMarketTokensApiResponse>
    */
-  async getMoneyMarketReserveAssets() {
+  async getMoneyMarketReserveAssets(config) {
     return this.makeRequest("/config/money-market/reserve-assets", {
+      ...config,
       method: "GET"
     });
   }
@@ -26176,8 +27128,9 @@ var BackendApiService = class {
    * @param chainId - Spoke chain id
    * @returns Promise<GetMoneyMarketTokensByChainIdApiResponse>
    */
-  async getMoneyMarketTokensByChainId(chainId) {
+  async getMoneyMarketTokensByChainId(chainId, config) {
     return this.makeRequest(`/config/money-market/${chainId}/tokens`, {
+      ...config,
       method: "GET"
     });
   }
@@ -26185,30 +27138,39 @@ var BackendApiService = class {
    * Get all supported hub assets (assets representing spoke token deposit)
    * @returns Promise<GetHubAssetsApiResponse>
    */
-  async getHubAssets() {
-    return this.makeRequest("/config/hub/assets", { method: "GET" });
+  async getHubAssets(config) {
+    return this.makeRequest("/config/hub/assets", { ...config, method: "GET" });
   }
   /**
    * Get supported hub assets (assets representing spoke token deposit) for a specific spoke chain
    * @param chainId - Spoke chain id
    * @returns Promise<GetHubAssetsByChainIdApiResponse>
    */
-  async getHubAssetsByChainId(chainId) {
-    return this.makeRequest(`/config/hub/${chainId}/assets`, { method: "GET" });
+  async getHubAssetsByChainId(chainId, config) {
+    return this.makeRequest(`/config/hub/${chainId}/assets`, {
+      ...config,
+      method: "GET"
+    });
   }
   /**
    * Get the intent relay chain id map
    * @returns Promise<GetRelayChainIdMapApiResponse>
    */
-  async getRelayChainIdMap() {
-    return this.makeRequest("/config/relay/chain-id-map", { method: "GET" });
+  async getRelayChainIdMap(config) {
+    return this.makeRequest("/config/relay/chain-id-map", {
+      ...config,
+      method: "GET"
+    });
   }
   /**
    * Get the spoke chain config
    * @returns Promise<GetSpokeChainConfigApiResponse>
    */
-  async getSpokeChainConfig() {
-    return this.makeRequest("/config/spoke/all-chains-configs", { method: "GET" });
+  async getSpokeChainConfig(config) {
+    return this.makeRequest("/config/spoke/all-chains-configs", {
+      ...config,
+      method: "GET"
+    });
   }
   /**
    * Set custom headers for API requests
@@ -26473,7 +27435,7 @@ var BridgeService = class {
       }
       const packetResult = await relayTxAndWaitPacket(
         txResult.value,
-        spokeProvider instanceof SolanaSpokeProvider ? txResult.data : void 0,
+        spokeProvider instanceof SolanaSpokeProvider || spokeProvider instanceof BitcoinSpokeProvider ? txResult.data : void 0,
         spokeProvider,
         this.relayerApiEndpoint,
         timeout
@@ -26546,7 +27508,11 @@ var BridgeService = class {
       const dstAssetInfo = this.configService.getHubAssetInfo(params.dstChainId, params.dstAsset);
       invariant6__default.default(srcAssetInfo, `Unsupported spoke chain (${params.srcChainId}) token: ${params.srcAsset}`);
       invariant6__default.default(dstAssetInfo, `Unsupported spoke chain (${params.dstChainId}) token: ${params.dstAsset}`);
-      const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      let walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      if (spokeProvider instanceof BitcoinSpokeProvider && spokeProvider.walletMode === "TRADING") {
+        const tradingWallet = await spokeProvider.radfi.getTradingWallet(walletAddress);
+        walletAddress = tradingWallet.tradingAddress;
+      }
       const hubWallet = await WalletAbstractionService.getUserAbstractedWalletAddress(
         walletAddress,
         spokeProvider,
@@ -30080,11 +31046,16 @@ var BalnSwapService = class {
 exports.ARBITRUM_MAINNET_CHAIN_ID = ARBITRUM_MAINNET_CHAIN_ID;
 exports.AVALANCHE_MAINNET_CHAIN_ID = AVALANCHE_MAINNET_CHAIN_ID;
 exports.BASE_MAINNET_CHAIN_ID = BASE_MAINNET_CHAIN_ID;
+exports.BITCOIN_MAINNET_CHAIN_ID = BITCOIN_MAINNET_CHAIN_ID;
 exports.BSC_MAINNET_CHAIN_ID = BSC_MAINNET_CHAIN_ID;
 exports.BackendApiService = BackendApiService;
 exports.BalnSwapService = BalnSwapService;
 exports.BigIntToHex = BigIntToHex;
 exports.BigNumberZeroDecimal = BigNumberZeroDecimal;
+exports.BitcoinBaseSpokeProvider = BitcoinBaseSpokeProvider;
+exports.BitcoinRawSpokeProvider = BitcoinRawSpokeProvider;
+exports.BitcoinSpokeProvider = BitcoinSpokeProvider;
+exports.BitcoinSpokeService = BitcoinSpokeService;
 exports.BnUSDMigrationService = BnUSDMigrationService;
 exports.BridgeService = BridgeService;
 exports.CHAIN_IDS = CHAIN_IDS;
@@ -30161,6 +31132,7 @@ exports.ProtocolIntentsAbi = ProtocolIntentsAbi;
 exports.RAY = RAY;
 exports.RAY_DECIMALS = RAY_DECIMALS;
 exports.REDBELLY_MAINNET_CHAIN_ID = REDBELLY_MAINNET_CHAIN_ID;
+exports.RadfiProvider = RadfiProvider;
 exports.SECONDS_PER_YEAR = SECONDS_PER_YEAR;
 exports.SOLANA_MAINNET_CHAIN_ID = SOLANA_MAINNET_CHAIN_ID;
 exports.SONIC_MAINNET_CHAIN_ID = SONIC_MAINNET_CHAIN_ID;
@@ -30226,6 +31198,7 @@ exports.convertTransactionInstructionToRaw = convertTransactionInstructionToRaw;
 exports.defaultSharedConfig = defaultSharedConfig;
 exports.defaultSodaxConfig = defaultSodaxConfig;
 exports.deriveUserWalletAddress = deriveUserWalletAddress;
+exports.detectBitcoinAddressType = detectBitcoinAddressType;
 exports.encodeAddress = encodeAddress;
 exports.encodeContractCalls = encodeContractCalls;
 exports.erc20Abi = erc20Abi;
@@ -30264,6 +31237,9 @@ exports.hubChainConfig = hubChainConfig;
 exports.hyper = hyper;
 exports.isAddressString = isAddressString;
 exports.isBalnMigrateParams = isBalnMigrateParams;
+exports.isBitcoinRawSpokeProvider = isBitcoinRawSpokeProvider;
+exports.isBitcoinSpokeProvider = isBitcoinSpokeProvider;
+exports.isBitcoinSpokeProviderType = isBitcoinSpokeProviderType;
 exports.isConfiguredMoneyMarketConfig = isConfiguredMoneyMarketConfig;
 exports.isConfiguredSolverConfig = isConfiguredSolverConfig;
 exports.isCreateIntentAutoSwapError = isCreateIntentAutoSwapError;
@@ -30331,6 +31307,8 @@ exports.isStellarRawSpokeProvider = isStellarRawSpokeProvider;
 exports.isStellarRawSpokeProviderConfig = isStellarRawSpokeProviderConfig;
 exports.isStellarSpokeProvider = isStellarSpokeProvider;
 exports.isStellarSpokeProviderType = isStellarSpokeProviderType;
+exports.isSubmitSwapTxResponse = isSubmitSwapTxResponse;
+exports.isSubmitSwapTxStatusResponse = isSubmitSwapTxStatusResponse;
 exports.isSuiRawSpokeProvider = isSuiRawSpokeProvider;
 exports.isSuiSpokeProvider = isSuiSpokeProvider;
 exports.isSuiSpokeProviderType = isSuiSpokeProviderType;
@@ -30345,6 +31323,7 @@ exports.nativeToUSD = nativeToUSD;
 exports.newbnUSDSpokeChainIds = newbnUSDSpokeChainIds;
 exports.normalize = normalize;
 exports.normalizeBN = normalizeBN;
+exports.normalizePsbtToBase64 = normalizePsbtToBase64;
 exports.normalizedToUsd = normalizedToUsd;
 exports.parseToStroops = parseToStroops;
 exports.parseTokenArrayFromJson = parseTokenArrayFromJson;