@uswap/toolboxes 4.3.7 → 4.3.10

package/src/solana/toolbox.ts

@@ -1,3 +1,9 @@
+/**
+ * Based on code from SwapKit (https://github.com/swapkit/SwapKit),
+ * licensed under the Apache License 2.0.
+ * Modifications © 2025 Horizontal Systems.
+ */
+
 import type {
   Connection,
   PublicKey,
@@ -16,7 +22,7 @@ import {
   getChainConfig,
   getRPCUrl,
   NetworkDerivationPath,
-  SwapKitError,
+  USwapError,
   updateDerivationPath,
 } from "@uswap/helpers";
 import { match, P } from "ts-pattern";
@@ -67,17 +73,11 @@ async function getSolanaBalance(address: string) {
   const { PublicKey } = await import("@solana/web3.js");
   const { TOKEN_PROGRAM_ID } = await import("@solana/spl-token");
   const publicKey = new PublicKey(address);
+  const { baseDecimal } = getChainConfig(Chain.Solana);
 
-  const balances: AssetValue[] = [];
-
-  // Get SOL balance
   const solBalance = await connection.getBalance(publicKey);
-  if (solBalance > 0) {
-    const { baseDecimal } = getChainConfig(Chain.Solana);
-    balances.push(AssetValue.from({ chain: Chain.Solana, fromBaseDecimal: baseDecimal, value: solBalance }));
-  }
+  const balances = [AssetValue.from({ chain: Chain.Solana, fromBaseDecimal: baseDecimal, value: solBalance || 0 })];
 
-  // Get token balances
   const tokenAccounts = await connection.getParsedTokenAccountsByOwner(publicKey, { programId: TOKEN_PROGRAM_ID });
 
   for (const { account } of tokenAccounts.value) {
@@ -133,7 +133,7 @@ export async function getSolanaToolbox(
 
   function getBalance(addressParam?: string) {
     const address = addressParam || getAddress();
-    if (!address) throw new SwapKitError("core_wallet_connection_not_found");
+    if (!address) throw new USwapError("core_wallet_connection_not_found");
     return getSolanaBalance(address);
   }
 
@@ -176,7 +176,7 @@ function estimateTransactionFee(getConnection: () => Promise<Connection>) {
     const feeInLamports = await connection.getFeeForMessage(message);
 
     if (feeInLamports.value === null) {
-      throw new SwapKitError("toolbox_solana_fee_estimation_failed", "Could not estimate Solana fee.");
+      throw new USwapError("toolbox_solana_fee_estimation_failed", "Could not estimate Solana fee.");
     }
 
     const { baseDecimal } = getChainConfig(Chain.Solana);
@@ -289,7 +289,7 @@ function createTransaction(getConnection: () => Promise<Connection>) {
     const validateAddress = await getSolanaAddressValidator();
 
     if (!(isProgramDerivedAddress || validateAddress(recipient))) {
-      throw new SwapKitError("core_transaction_invalid_recipient_address");
+      throw new USwapError("core_transaction_invalid_recipient_address");
     }
 
     const connection = await getConnection();
@@ -301,7 +301,7 @@ function createTransaction(getConnection: () => Promise<Connection>) {
     });
 
     if (!transaction) {
-      throw new SwapKitError("core_transaction_invalid_sender_address");
+      throw new USwapError("core_transaction_invalid_sender_address");
     }
 
     if (memo) transaction.add(createMemoInstruction(memo));
@@ -324,7 +324,7 @@ async function createTransactionFromInstructions({
   const transaction = new Transaction().add(...instructions);
 
   if (!transaction) {
-    throw new SwapKitError("core_transaction_invalid_sender_address");
+    throw new USwapError("core_transaction_invalid_sender_address");
   }
 
   return transaction;
@@ -333,7 +333,7 @@ async function createTransactionFromInstructions({
 function transfer(getConnection: () => Promise<Connection>, signer?: SolanaSigner) {
   return async ({ recipient, assetValue, memo, isProgramDerivedAddress }: SolanaTransferParams) => {
     if (!signer) {
-      throw new SwapKitError("core_transaction_invalid_sender_address");
+      throw new USwapError("core_transaction_invalid_sender_address");
     }
 
     const sender = signer.publicKey?.toString() ?? (await (signer as SolanaProvider).connect()).publicKey.toString();
@@ -368,7 +368,7 @@ function signTransaction(getConnection: () => Promise<Connection>, signer?: Sola
   return async (transaction: Transaction | VersionedTransaction) => {
     const { VersionedTransaction } = await import("@solana/web3.js");
     if (!signer) {
-      throw new SwapKitError("toolbox_solana_no_signer");
+      throw new USwapError("toolbox_solana_no_signer");
     }
 
     if (!(transaction instanceof VersionedTransaction)) {

package/src/substrate/balance.ts

@@ -29,7 +29,7 @@ export async function getSubstrateBalance(
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     console.error(`Error fetching substrate balance: ${errorMessage}`);
-    return [];
+    return [gasAsset.set(0)];
   }
 }
 
@@ -66,7 +66,7 @@ export async function getChainflipBalance(
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     console.error(`Error fetching chainflip balance: ${errorMessage}`);
-    return [];
+    return [gasAsset.set(0)];
   }
 }
 

package/src/substrate/substrate.ts

@@ -1,3 +1,9 @@
+/**
+ * Based on code from SwapKit (https://github.com/swapkit/SwapKit),
+ * licensed under the Apache License 2.0.
+ * Modifications © 2025 Horizontal Systems.
+ */
+
 import type { ApiPromise } from "@polkadot/api";
 import type { SubmittableExtrinsic } from "@polkadot/api/types";
 import type { KeyringPair } from "@polkadot/keyring/types";
@@ -11,8 +17,8 @@ import {
   type GenericCreateTransactionParams,
   getRPCUrl,
   type SubstrateChain,
-  SwapKitError,
   SwapKitNumber,
+  USwapError,
 } from "@uswap/helpers";
 
 import { match, P } from "ts-pattern";
@@ -43,7 +49,7 @@ export function getSubstrateToolbox<T extends SubstrateChain>(chain: T, params?:
       return PolkadotToolbox(params);
     }
     default:
-      throw new SwapKitError("toolbox_substrate_not_supported", { chain });
+      throw new USwapError("toolbox_substrate_not_supported", { chain });
   }
 }
 
@@ -82,12 +88,12 @@ const transfer = async (
   { recipient, assetValue, sender }: SubstrateTransferParams,
 ) => {
   const transfer = createTransaction(api, { assetValue, recipient });
-  if (!transfer) throw new SwapKitError("toolbox_substrate_transfer_error");
+  if (!transfer) throw new USwapError("toolbox_substrate_transfer_error");
 
   const isKeyring = isKeyringPair(signer);
 
   const address = isKeyring ? (signer as IKeyringPair).address : sender;
-  if (!address) throw new SwapKitError("core_transaction_invalid_sender_address");
+  if (!address) throw new USwapError("core_transaction_invalid_sender_address");
 
   const nonce = await getNonce(api, address);
 
@@ -199,23 +205,23 @@ export const BaseSubstrateToolbox = ({
   decodeAddress,
   encodeAddress,
   estimateTransactionFee: (params: SubstrateTransferParams) => {
-    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (!signer) throw new USwapError("core_wallet_not_keypair_wallet");
     return estimateTransactionFee(api, signer, gasAsset, params);
   },
   gasAsset,
   getAddress: (keyring?: IKeyringPair | Signer) => {
     const keyringPair = keyring || signer;
-    if (!keyringPair) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (!keyringPair) throw new USwapError("core_wallet_not_keypair_wallet");
 
     return isKeyringPair(keyringPair) ? keyringPair.address : undefined;
   },
   getBalance: createBalanceGetter(chain || Chain.Polkadot, api),
   network,
   sign: (tx: SubmittableExtrinsic<"promise">) => {
-    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (!signer) throw new USwapError("core_wallet_not_keypair_wallet");
     if (isKeyringPair(signer)) return sign(signer, tx);
 
-    throw new SwapKitError(
+    throw new USwapError(
       "core_wallet_not_keypair_wallet",
       "Signer does not have keyring pair capabilities required for signing.",
     );
@@ -229,20 +235,20 @@ export const BaseSubstrateToolbox = ({
     callback?: Callback<ISubmittableResult>;
     address?: string;
   }) => {
-    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (!signer) throw new USwapError("core_wallet_not_keypair_wallet");
     if (isKeyringPair(signer)) return signAndBroadcastKeyring(signer, tx, callback);
 
     if (address) {
       return signAndBroadcast({ address, api, callback, signer, tx });
     }
 
-    throw new SwapKitError(
+    throw new USwapError(
       "core_wallet_not_keypair_wallet",
       "Signer does not have keyring pair capabilities required for signing.",
     );
   },
   transfer: (params: SubstrateTransferParams) => {
-    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (!signer) throw new USwapError("core_wallet_not_keypair_wallet");
     return transfer(api, signer, params);
   },
   validateAddress: (address: string) => validateAddress(address, network.prefix),

package/src/sui/__tests__/toolbox.test.ts

@@ -42,11 +42,15 @@ describe("Sui Toolbox", () => {
     }
   });
 
-  test("should fetch balance for known address", async () => {
-    const balances = await context.toolbox.getBalance(KNOWN_SUI_ADDRESS);
-    expect(balances[0]?.chain).toBe(Chain.Sui);
-    expect(balances[0]?.symbol).toBe("SUI");
-  });
+  test(
+    "should fetch balance for known address",
+    async () => {
+      const balances = await context.toolbox.getBalance(KNOWN_SUI_ADDRESS);
+      expect(balances[0]?.chain).toBe(Chain.Sui);
+      expect(balances[0]?.symbol).toBe("SUI");
+    },
+    { retry: 3, timeout: 10000 },
+  );
 
   test("should estimate transaction fee", async () => {
     const fee = await context.toolbox.estimateTransactionFee();

package/src/sui/toolbox.ts

@@ -1,4 +1,10 @@
-import { AssetValue, Chain, getChainConfig, SwapKitError } from "@uswap/helpers";
+/**
+ * Based on code from SwapKit (https://github.com/swapkit/SwapKit),
+ * licensed under the Apache License 2.0.
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { AssetValue, Chain, getChainConfig, USwapError } from "@uswap/helpers";
 import { match, P } from "ts-pattern";
 import type { SuiCreateTransactionParams, SuiToolboxParams, SuiTransferParams } from "./types";
 
@@ -37,13 +43,14 @@ export async function getSuiToolbox({ provider: providerParam, ...signerParams }
   async function getBalance(targetAddress?: string) {
     const addressToQuery = targetAddress || getAddress();
     if (!addressToQuery) {
-      throw new SwapKitError("toolbox_sui_address_required" as any);
+      throw new USwapError("toolbox_sui_address_required" as any);
     }
 
+    const { baseDecimal: fromBaseDecimal, chain } = getChainConfig(Chain.Sui);
+
     try {
       const suiClient = await getSuiClient();
       const { totalBalance } = await suiClient.getBalance({ owner: addressToQuery });
-      const { baseDecimal: fromBaseDecimal, chain } = getChainConfig(Chain.Sui);
 
       const suiBalances = [AssetValue.from({ chain, fromBaseDecimal, value: totalBalance })];
 
@@ -60,8 +67,8 @@ export async function getSuiToolbox({ provider: providerParam, ...signerParams }
       }
 
       return suiBalances;
-    } catch (error) {
-      throw new SwapKitError("toolbox_sui_balance_error" as any, { error });
+    } catch {
+      return [AssetValue.from({ chain })];
     }
   }
 
@@ -93,7 +100,7 @@ export async function getSuiToolbox({ provider: providerParam, ...signerParams }
     const senderAddress = sender || getAddress();
 
     if (!senderAddress) {
-      throw new SwapKitError("toolbox_sui_no_sender");
+      throw new USwapError("toolbox_sui_no_sender");
     }
 
     try {
@@ -104,7 +111,7 @@ export async function getSuiToolbox({ provider: providerParam, ...signerParams }
         const [suiCoin] = tx.splitCoins(tx.gas, [assetValue.getBaseValue("string")]);
         tx.transferObjects([suiCoin], recipient);
       } else {
-        throw new SwapKitError("toolbox_sui_custom_token_transfer_not_implemented" as any);
+        throw new USwapError("toolbox_sui_custom_token_transfer_not_implemented" as any);
       }
 
       if (gasBudget) {
@@ -116,7 +123,7 @@ export async function getSuiToolbox({ provider: providerParam, ...signerParams }
 
       return { tx, txBytes };
     } catch (error) {
-      throw new SwapKitError("toolbox_sui_transaction_creation_error" as any, { error });
+      throw new USwapError("toolbox_sui_transaction_creation_error" as any, { error });
     }
   }
 
@@ -124,7 +131,7 @@ export async function getSuiToolbox({ provider: providerParam, ...signerParams }
     params: Uint8Array<ArrayBuffer> | SuiCreateTransactionParams | Awaited<ReturnType<typeof createTransaction>>,
   ) {
     if (!signer) {
-      throw new SwapKitError("toolbox_sui_no_signer");
+      throw new USwapError("toolbox_sui_no_signer");
     }
 
     if (params instanceof Uint8Array) {
@@ -138,12 +145,12 @@ export async function getSuiToolbox({ provider: providerParam, ...signerParams }
 
   async function transfer({ assetValue, gasBudget, recipient }: SuiTransferParams) {
     if (!signer) {
-      throw new SwapKitError("toolbox_sui_no_signer" as any);
+      throw new USwapError("toolbox_sui_no_signer" as any);
     }
 
     const sender = signer.toSuiAddress() || getAddress();
     if (!sender) {
-      throw new SwapKitError("toolbox_sui_no_sender");
+      throw new USwapError("toolbox_sui_no_sender");
     }
 
     const { txBytes } = await createTransaction({ assetValue, gasBudget, recipient, sender });

package/src/ton/__tests__/toolbox.test.ts

@@ -39,11 +39,15 @@ describe("TON Toolbox", () => {
     expect(context.toolbox.validateAddress(address)).toBe(true);
   });
 
-  test("should fetch balance for known address", async () => {
-    const balances = await context.toolbox.getBalance(KNOWN_TON_ADDRESS);
-    expect(balances[0]?.chain).toBe(Chain.Ton);
-    expect(balances[0]?.symbol).toBe("TON");
-  });
+  test(
+    "should fetch balance for known address",
+    async () => {
+      const balances = await context.toolbox.getBalance(KNOWN_TON_ADDRESS);
+      expect(balances[0]?.chain).toBe(Chain.Ton);
+      expect(balances[0]?.symbol).toBe("TON");
+    },
+    { retry: 3, timeout: 10000 },
+  );
 
   test("should estimate transaction fee", async () => {
     const fee = await context.toolbox.estimateTransactionFee();

package/src/ton/toolbox.ts

@@ -1,5 +1,11 @@
+/**
+ * Based on code from SwapKit (https://github.com/swapkit/SwapKit),
+ * licensed under the Apache License 2.0.
+ * Modifications © 2025 Horizontal Systems.
+ */
+
 import type { Cell, OpenedContract, TonClient, WalletContractV4 } from "@ton/ton";
-import { AssetValue, Chain, getChainConfig, SwapKitError, SwapKitNumber } from "@uswap/helpers";
+import { AssetValue, Chain, getChainConfig, SwapKitNumber, USwapError } from "@uswap/helpers";
 import { match, P } from "ts-pattern";
 
 import type { TONSigner, TONToolboxParams, TONTransferParams } from "./types";
@@ -33,7 +39,7 @@ export async function getTONToolbox(toolboxParams: TONToolboxParams = {}) {
       const walletSigner = paramSigner || signer;
 
       if (!walletSigner) {
-        throw new SwapKitError("core_wallet_connection_not_found");
+        throw new USwapError("core_wallet_connection_not_found");
       }
 
       const walletContract = WalletContractV4.create({ publicKey: walletSigner.publicKey, workchain: 0 });
@@ -52,15 +58,15 @@ export async function getTONToolbox(toolboxParams: TONToolboxParams = {}) {
     try {
       const balance = await client.getBalance(Address.parse(address));
       return [AssetValue.from({ chain: Chain.Ton, value: SwapKitNumber.fromBigInt(balance, baseDecimal) })];
-    } catch (error) {
-      throw new SwapKitError("core_wallet_connection_not_found", { error });
+    } catch {
+      return [AssetValue.from({ chain: Chain.Ton })];
     }
   }
 
   async function createTransaction({ assetValue, recipient, memo }: TONTransferParams) {
     const wallet = getWallet();
     if (!wallet || !signer) {
-      throw new SwapKitError("core_wallet_connection_not_found");
+      throw new USwapError("core_wallet_connection_not_found");
     }
 
     const { toNano, comment, internal } = await import("@ton/ton");
@@ -80,7 +86,7 @@ export async function getTONToolbox(toolboxParams: TONToolboxParams = {}) {
   async function transfer({ assetValue, recipient, memo }: TONTransferParams) {
     const wallet = getWallet();
     if (!wallet || !signer) {
-      throw new SwapKitError("core_wallet_connection_not_found");
+      throw new USwapError("core_wallet_connection_not_found");
     }
 
     const transfer = await createTransaction({ assetValue, memo, recipient });
@@ -92,14 +98,14 @@ export async function getTONToolbox(toolboxParams: TONToolboxParams = {}) {
   async function sendTransaction(transferCell: Cell) {
     const wallet = getWallet();
     if (!wallet) {
-      throw new SwapKitError("core_wallet_connection_not_found");
+      throw new USwapError("core_wallet_connection_not_found");
     }
 
     try {
       await wallet.send(transferCell);
       return transferCell.hash().toString("hex");
     } catch (error) {
-      throw new SwapKitError("core_wallet_connection_not_found", { error });
+      throw new USwapError("core_wallet_connection_not_found", { error });
     }
   }
 

package/src/tron/helpers/trongrid.ts

@@ -1,4 +1,10 @@
-import { SwapKitError } from "@uswap/helpers";
+/**
+ * Based on code from SwapKit (https://github.com/swapkit/SwapKit),
+ * licensed under the Apache License 2.0.
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { USwapError } from "@uswap/helpers";
 import type { TronGridAccountResponse } from "../types";
 
 const TRONGRID_API_BASE = "https://api.trongrid.io";
@@ -45,7 +51,7 @@ export async function fetchAccountFromTronGrid(address: string) {
     // Return simplified object with balance and trc20 array
     return { balance: account.balance, trc20: account.trc20 || [] };
   } catch (error) {
-    throw new SwapKitError("toolbox_tron_trongrid_api_error", {
+    throw new USwapError("toolbox_tron_trongrid_api_error", {
       address,
       message: error instanceof Error ? error.message : "Unknown error",
     });

package/src/tron/toolbox.ts

@@ -1,3 +1,9 @@
+/**
+ * Based on code from SwapKit (https://github.com/swapkit/SwapKit),
+ * licensed under the Apache License 2.0.
+ * Modifications © 2025 Horizontal Systems.
+ */
+
 import {
   AssetValue,
   BaseDecimal,
@@ -5,7 +11,7 @@ import {
   derivationPathToString,
   getRPCUrl,
   NetworkDerivationPath,
-  SwapKitError,
+  USwapError,
   updateDerivationPath,
   warnOnce,
 } from "@uswap/helpers";
@@ -65,7 +71,7 @@ export async function getTronPrivateKeyFromMnemonic({
   const derived = hdKey.derive(derivationPathToUse);
 
   if (!derived.privateKey) {
-    throw new SwapKitError("toolbox_tron_no_signer");
+    throw new USwapError("toolbox_tron_no_signer");
   }
 
   return Buffer.from(derived.privateKey).toString("hex");
@@ -88,7 +94,7 @@ async function createKeysForPath({
   const derived = hdKey.derive(derivationPath);
 
   if (!derived.privateKey) {
-    throw new SwapKitError("toolbox_tron_no_signer");
+    throw new USwapError("toolbox_tron_no_signer");
   }
 
   // Convert private key to hex string for TronWeb
@@ -147,7 +153,7 @@ export const createTronToolbox = async (
     .otherwise(() => Promise.resolve(undefined));
 
   const getAddress = async () => {
-    if (!signer) throw new SwapKitError("toolbox_tron_no_signer");
+    if (!signer) throw new USwapError("toolbox_tron_no_signer");
     return await signer.getAddress();
   };
 
@@ -338,7 +344,7 @@ export const createTronToolbox = async (
   };
 
   const transfer = async ({ recipient, assetValue, memo, expiration }: TronTransferParams) => {
-    if (!signer) throw new SwapKitError("toolbox_tron_no_signer");
+    if (!signer) throw new USwapError("toolbox_tron_no_signer");
 
     const from = await getAddress();
     tronWeb.setAddress(from);
@@ -348,7 +354,7 @@ export const createTronToolbox = async (
     const { txid } = await tronWeb.trx.sendRawTransaction(signedTx);
 
     if (!txid) {
-      throw new SwapKitError("toolbox_tron_token_transfer_failed");
+      throw new USwapError("toolbox_tron_token_transfer_failed");
     }
 
     return txid;
@@ -422,7 +428,7 @@ export const createTronToolbox = async (
         }`,
       });
 
-      throw new SwapKitError("toolbox_tron_fee_estimation_failed", { error });
+      throw new USwapError("toolbox_tron_fee_estimation_failed", { error });
     }
   };
 
@@ -464,7 +470,7 @@ export const createTronToolbox = async (
     tronWeb.setAddress(sender);
     const contractAddress = assetValue.address;
     if (!contractAddress) {
-      throw new SwapKitError("toolbox_tron_invalid_token_identifier", { identifier: assetValue.toString() });
+      throw new USwapError("toolbox_tron_invalid_token_identifier", { identifier: assetValue.toString() });
     }
 
     try {
@@ -487,7 +493,7 @@ export const createTronToolbox = async (
       const txWithData = addTxData({ expiration, memo, transaction });
       return txWithData;
     } catch (error) {
-      throw new SwapKitError("toolbox_tron_transaction_creation_failed", {
+      throw new USwapError("toolbox_tron_transaction_creation_failed", {
         message: "Failed to create TRC20 transaction.",
         originalError: error instanceof Error ? error.message : String(error),
       });
@@ -495,7 +501,7 @@ export const createTronToolbox = async (
   };
 
   const signTransaction = async (transaction: TronTransaction) => {
-    if (!signer) throw new SwapKitError("toolbox_tron_no_signer");
+    if (!signer) throw new USwapError("toolbox_tron_no_signer");
     return await signer.signTransaction(transaction);
   };
 
@@ -509,14 +515,14 @@ export const createTronToolbox = async (
       const contract = tronWeb.contract(trc20ABI, assetAddress);
 
       if (!contract.methods?.allowance) {
-        throw new SwapKitError("toolbox_tron_invalid_token_contract");
+        throw new USwapError("toolbox_tron_invalid_token_contract");
       }
 
       const [allowance] = await contract.methods.allowance(from, spenderAddress).call();
 
       return allowance ? (typeof allowance === "bigint" ? allowance : BigInt(allowance)) : 0n;
     } catch (error) {
-      throw new SwapKitError("toolbox_tron_allowance_check_failed", { error });
+      throw new USwapError("toolbox_tron_allowance_check_failed", { error });
     }
   };
 
@@ -532,7 +538,7 @@ export const createTronToolbox = async (
   };
 
   const approve = async ({ assetAddress, spenderAddress, amount, from }: TronApproveParams) => {
-    if (!signer) throw new SwapKitError("toolbox_tron_no_signer");
+    if (!signer) throw new USwapError("toolbox_tron_no_signer");
 
     const fromAddress = from || (await getAddress());
     const approvalAmount = amount !== undefined ? BigInt(amount).toString() : MAX_APPROVAL;
@@ -559,12 +565,12 @@ export const createTronToolbox = async (
       const { txid } = await tronWeb.trx.sendRawTransaction(signedTx);
 
       if (!txid) {
-        throw new SwapKitError("toolbox_tron_approve_failed");
+        throw new USwapError("toolbox_tron_approve_failed");
       }
 
       return txid;
     } catch (error) {
-      throw new SwapKitError("toolbox_tron_approve_failed", { error });
+      throw new USwapError("toolbox_tron_approve_failed", { error });
     }
   };
 

package/src/utils.ts

@@ -20,8 +20,15 @@ export function getBalance<T extends Chain>(chain: T) {
   return async function getBalance(address: string, scamFilter = true) {
     const balances = await SwapKitApi.getChainBalance({ address, chain, scamFilter });
     const { baseDecimal } = getChainConfig(chain);
-    return balances.map(({ identifier, value, decimal }) => {
+    const assetValues = balances.map(({ identifier, value, decimal }) => {
       return new AssetValue({ decimal: decimal || baseDecimal, identifier, value });
     });
+
+    const hasNativeAsset = assetValues.some((asset) => asset.isGasAsset);
+    if (!hasNativeAsset) {
+      return [AssetValue.from({ chain }), ...assetValues];
+    }
+
+    return assetValues;
   };
 }

package/src/utxo/helpers/api.ts

@@ -1,5 +1,11 @@
+/**
+ * Based on code from SwapKit (https://github.com/swapkit/SwapKit),
+ * licensed under the Apache License 2.0.
+ * Modifications © 2025 Horizontal Systems.
+ */
+
 import { networks as zcashNetworks } from "@bitgo/utxo-lib";
-import { Chain, getRPCUrl, RequestClient, SKConfig, SwapKitError, type UTXOChain, warnOnce } from "@uswap/helpers";
+import { Chain, getRPCUrl, RequestClient, SKConfig, USwapError, type UTXOChain, warnOnce } from "@uswap/helpers";
 import { networks } from "bitcoinjs-lib";
 // @ts-expect-error
 import coininfo from "coininfo";
@@ -26,7 +32,7 @@ async function broadcastUTXOTx({ chain, txHash }: { chain: Chain; txHash: string
     }>(url, { body, headers: { "Content-Type": "application/json" } });
 
     if (response.context.code !== 200) {
-      throw new SwapKitError("toolbox_utxo_broadcast_failed", {
+      throw new USwapError("toolbox_utxo_broadcast_failed", {
         error: response.context.error || "Transaction broadcast failed",
       });
     }
@@ -45,11 +51,11 @@ async function broadcastUTXOTx({ chain, txHash }: { chain: Chain; txHash: string
       }>(rpcUrl, { body: rpcBody, headers: { "Content-Type": "application/json" } });
 
       if (rpcResponse.error) {
-        throw new SwapKitError("toolbox_utxo_broadcast_failed", { error: rpcResponse.error?.message });
+        throw new USwapError("toolbox_utxo_broadcast_failed", { error: rpcResponse.error?.message });
       }
 
       if (rpcResponse.result.includes('"code":-26')) {
-        throw new SwapKitError("toolbox_utxo_invalid_transaction", { error: "Transaction amount was too low" });
+        throw new USwapError("toolbox_utxo_invalid_transaction", { error: "Transaction amount was too low" });
       }
 
       return rpcResponse.result;
@@ -121,13 +127,13 @@ async function blockchairRequest<T>(url: string, apiKey?: string): Promise<T> {
   );
 
   if (!response || response.context.code !== 200)
-    throw new SwapKitError("toolbox_utxo_api_error", { error: `Failed to query ${url}` });
+    throw new USwapError("toolbox_utxo_api_error", { error: `Failed to query ${url}` });
 
   return response.data as T;
 }
 
 async function getAddressData({ address, chain, apiKey }: BlockchairParams<{ address?: string }>) {
-  if (!address) throw new SwapKitError("toolbox_utxo_invalid_params", { error: "Address is required" });
+  if (!address) throw new USwapError("toolbox_utxo_invalid_params", { error: "Address is required" });
 
   try {
     const response = await blockchairRequest<BlockchairAddressResponse>(
@@ -148,7 +154,7 @@ async function getUnconfirmedBalance({ address, chain, apiKey }: BlockchairParam
 }
 
 async function getRawTx({ chain, apiKey, txHash }: BlockchairParams<{ txHash?: string }>) {
-  if (!txHash) throw new SwapKitError("toolbox_utxo_invalid_params", { error: "TxHash is required" });
+  if (!txHash) throw new USwapError("toolbox_utxo_invalid_params", { error: "TxHash is required" });
 
   try {
     const rawTxResponse = await blockchairRequest<BlockchairRawTransactionResponse>(
@@ -223,7 +229,7 @@ async function getUnspentUtxos({
   offset = 0,
   limit = 30,
 }: BlockchairFetchUnspentUtxoParams): Promise<Awaited<ReturnType<typeof fetchUtxosBatch>>> {
-  if (!address) throw new SwapKitError("toolbox_utxo_invalid_params", { error: "Address is required" });
+  if (!address) throw new USwapError("toolbox_utxo_invalid_params", { error: "Address is required" });
 
   try {
     const utxos = await fetchUtxosBatch({ address, apiKey, chain, limit, offset, targetValue });
@@ -340,7 +346,7 @@ export function getUtxoNetwork() {
       }
 
       default:
-        throw new SwapKitError("toolbox_utxo_not_supported", { chain });
+        throw new USwapError("toolbox_utxo_not_supported", { chain });
     }
   };
 }