@sodax/sdk 0.0.1-rc.13 → 0.0.1-rc.15

package/README.md

@@ -225,8 +225,8 @@ As part of Sodax suite, xWagmi SDK is also going to be provided as one example w
   - `ISuiWalletProvider`: Sui ✅
   - `IIconWalletProvider`: ICON ✅
   - `IStellarWalletProvider`: Stellar ✅
-  - Solana ❌ Coming soon
-  - Injective ❌ Coming soon
+  - Solana ✅
+  - Injective ✅
   - Havah ❌ Coming soon
 
 ### Initialising Spoke Provider
@@ -251,6 +251,86 @@ const bscSpokeProvider: EvmSpokeProvider = new EvmSpokeProvider(
 );
 ```
 
+### Estimate Gas for Raw Transactions
+
+The `estimateGas` function allows you to estimate the gas cost for raw transactions before executing them. This is particularly useful for all Sodax operations (swaps, money market operations, approvals) to provide users with accurate gas estimates.
+
+The function is available on all service classes:
+- `SolverService.estimateGas()` - for solver/intent operations
+- `MoneyMarketService.estimateGas()` - for money market operations
+- `SpokeService.estimateGas()` - for general spoke chain operations
+
+```typescript
+import { 
+  SolverService, 
+  MoneyMarketService, 
+  SpokeService,
+  MoneyMarketSupplyParams 
+} from "@sodax/sdk";
+
+// Example: Estimate gas for a solver swap transaction
+const createIntentResult = await sodax.solver.createIntent(
+  createIntentParams,
+  bscSpokeProvider,
+  partnerFeeAmount,
+  true, // true = get raw transaction
+);
+
+if (createIntentResult.ok) {
+  const [rawTx, intent] = createIntentResult.value;
+  
+  // Estimate gas for the raw transaction
+  const gasEstimate = await SolverService.estimateGas(rawTx, bscSpokeProvider);
+  
+  if (gasEstimate.ok) {
+    console.log('Estimated gas for swap:', gasEstimate.value);
+  } else {
+    console.error('Failed to estimate gas for swap:', gasEstimate.error);
+  }
+}
+
+// Example: Estimate gas for a money market supply transaction
+const supplyResult = await sodax.moneyMarket.createSupplyIntent(
+  supplyParams,
+  bscSpokeProvider,
+  true, // true = get raw transaction
+);
+
+if (supplyResult.ok) {
+  const rawTx = supplyResult.value;
+  
+  // Estimate gas for the raw transaction
+  const gasEstimate = await MoneyMarketService.estimateGas(rawTx, bscSpokeProvider);
+  
+  if (gasEstimate.ok) {
+    console.log('Estimated gas for supply:', gasEstimate.value);
+  } else {
+    console.error('Failed to estimate gas for supply:', gasEstimate.error);
+  }
+}
+
+// Example: Estimate gas for an approval transaction
+const approveResult = await sodax.solver.approve(
+  tokenAddress,
+  amount,
+  bscSpokeProvider,
+  true // true = get raw transaction
+);
+
+if (approveResult.ok) {
+  const rawTx = approveResult.value;
+  
+  // Estimate gas for the approval transaction
+  const gasEstimate = await SpokeService.estimateGas(rawTx, bscSpokeProvider);
+  
+  if (gasEstimate.ok) {
+    console.log('Estimated gas for approval:', gasEstimate.value);
+  } else {
+    console.error('Failed to estimate gas for approval:', gasEstimate.error);
+  }
+}
+```
+
 ### Accessing Sodax Features
 
 Sodax feature set currently contain:

package/dist/index.cjs

@@ -4,12 +4,16 @@ var viem = require('viem');
 var chains = require('viem/chains');
 var types = require('@sodax/types');
 var stargate = require('@cosmjs/stargate');
+var networks = require('@injectivelabs/networks');
+var sdkTs = require('@injectivelabs/sdk-ts');
 var IconSdkRaw = require('icon-sdk-js');
 var stellarSdk = require('@stellar/stellar-sdk');
 var bcs = require('@mysten/sui/bcs');
+var client = require('@mysten/sui/client');
 var transactions = require('@mysten/sui/transactions');
 var web3_js = require('@solana/web3.js');
 var invariant2 = require('tiny-invariant');
+var tx_js = require('cosmjs-types/cosmos/tx/v1beta1/tx.js');
 var rlp = require('rlp');
 var splToken = require('@solana/spl-token');
 var anchor = require('@coral-xyz/anchor');
@@ -5282,8 +5286,7 @@ var spokeChainConfig = {
       }
     },
     gasPrice: "500000",
-    rpcUrl: "https://solana-mainnet.g.alchemy.com/v2/i3q5fE3cYSFBE4Lcg1kS5",
-    wsUrl: "https://solana-mainnet.g.alchemy.com/v2/i3q5fE3cYSFBE4Lcg1kS5",
+    rpcUrl: "https://api.mainnet-beta.solana.com",
     walletAddress: ""
   },
   [types.AVALANCHE_MAINNET_CHAIN_ID]: {
@@ -6772,14 +6775,16 @@ var Injective20Token = class {
     return await this.client.execute(senderAddress, this.contractAddress, msg, "auto");
   }
 };
-
-// src/entities/injective/InjectiveSpokeProvider.ts
 var InjectiveSpokeProvider = class {
   walletProvider;
   chainConfig;
+  txClient;
   constructor(conf, walletProvider) {
     this.chainConfig = conf;
     this.walletProvider = walletProvider;
+    this.txClient = new sdkTs.TxGrpcClient(
+      networks.getNetworkEndpoints(this.chainConfig.network === "Mainnet" ? networks.Network.Mainnet : networks.Network.Testnet).grpc
+    );
   }
   // Query Methods
   async getState() {
@@ -6840,16 +6845,7 @@ var InjectiveSpokeProvider = class {
     return this.transfer(sender, token, to, amount, data, funds, raw);
   }
   async isNative(token) {
-    let isNative2 = true;
-    const injective20Token = new Injective20Token(this.walletProvider, token);
-    try {
-      await injective20Token.getTokenInfo();
-      isNative2 = false;
-    } catch (err) {
-      console.log("[InjectiveSpokeProvider] isNative error", err);
-      throw err;
-    }
-    return isNative2;
+    return token === "inj";
   }
   async receiveMessage(senderAddress, srcChainId, srcAddress, connSn, payload, signatures) {
     const msg = {
@@ -6923,10 +6919,12 @@ var IconSpokeProvider = class {
   walletProvider;
   chainConfig;
   iconService;
-  constructor(walletProvider, chainConfig, rpcUrl = "https://ctz.solidwallet.io/api/v3") {
+  debugRpcUrl;
+  constructor(walletProvider, chainConfig, rpcUrl = "https://ctz.solidwallet.io/api/v3", debugRpcUrl = "https://ctz.solidwallet.io/api/v3d") {
     this.walletProvider = walletProvider;
     this.chainConfig = chainConfig;
     this.iconService = new IconSdk.IconService(new IconSdk.IconService.HttpProvider(rpcUrl));
+    this.debugRpcUrl = debugRpcUrl;
   }
 };
 
@@ -7177,7 +7175,7 @@ var StellarSpokeProvider = class {
       networkPassphrase: network.passphrase
     }).addOperation(operation).setTimeout(STELLAR_DEFAULT_TX_TIMEOUT_SECONDS).build();
     const simulation = await this.sorobanServer.simulateTransaction(priorityTransaction);
-    return [stellarSdk.SorobanRpc.assembleTransaction(priorityTransaction, simulation).build(), simulation];
+    return [priorityTransaction, simulation];
   }
   handleSendTransactionError(response) {
     if (response.status === "ERROR") {
@@ -7265,9 +7263,14 @@ var StellarSpokeProvider = class {
       const accountResponse = await this.server.loadAccount(walletAddress);
       const stellarAccount = new CustomStellarAccount(accountResponse);
       const depositCall = this.buildDepositCall(walletAddress, token, amount, recipient, data);
-      const [priorityTx, simulation] = await this.buildPriorityStellarTransaction(stellarAccount, network, depositCall);
+      const [rawPriorityTx, simulation] = await this.buildPriorityStellarTransaction(
+        stellarAccount,
+        network,
+        depositCall
+      );
+      const assembledPriorityTx = stellarSdk.SorobanRpc.assembleTransaction(rawPriorityTx, simulation).build();
       if (raw) {
-        const transactionXdr = priorityTx.toXDR();
+        const transactionXdr = rawPriorityTx.toXDR();
         return {
           from: walletAddress,
           to: this.chainConfig.addresses.assetManager,
@@ -7275,7 +7278,13 @@ var StellarSpokeProvider = class {
           data: transactionXdr
         };
       }
-      const hash = await this.submitOrRestoreAndRetry(stellarAccount, network, priorityTx, depositCall, simulation);
+      const hash = await this.submitOrRestoreAndRetry(
+        stellarAccount,
+        network,
+        assembledPriorityTx,
+        depositCall,
+        simulation
+      );
       return `${hash}`;
     } catch (error) {
       console.error("Error during deposit:", error);
@@ -7344,9 +7353,11 @@ var StellarSpokeProvider = class {
 var SuiSpokeProvider = class _SuiSpokeProvider {
   walletProvider;
   chainConfig;
+  publicClient;
   constructor(config, wallet_provider) {
     this.chainConfig = config;
     this.walletProvider = wallet_provider;
+    this.publicClient = new client.SuiClient({ url: client.getFullnodeUrl("mainnet") });
   }
   async getBalance(token) {
     const assetmanager = this.splitAddress(this.chainConfig.addresses.assetManager);
@@ -7386,7 +7397,11 @@ var SuiSpokeProvider = class _SuiSpokeProvider {
       ]
     });
     if (raw) {
-      const transactionRaw = await tx.build();
+      tx.setSender(walletAddress);
+      const transactionRaw = await tx.build({
+        client: this.publicClient,
+        onlyTransactionKind: true
+      });
       const transactionRawBase64String = Buffer.from(transactionRaw).toString("base64");
       return {
         from: walletAddress,
@@ -7449,10 +7464,14 @@ var SuiSpokeProvider = class _SuiSpokeProvider {
         txb.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(data))
       ]
     });
+    const walletAddress = await this.walletProvider.getWalletAddress();
     if (raw) {
-      const transactionRaw = await txb.build();
+      txb.setSender(walletAddress);
+      const transactionRaw = await txb.build({
+        client: this.publicClient,
+        onlyTransactionKind: true
+      });
       const transactionRawBase64String = Buffer.from(transactionRaw).toString("base64");
-      const walletAddress = await this.walletProvider.getWalletAddressBytes();
       return {
         from: walletAddress,
         to: `${connection.packageId}::${connection.moduleId}::send_message_ua`,
@@ -8115,6 +8134,15 @@ function encodeAddress(spokeChainId, address) {
       return address;
   }
 }
+function hexToBigInt(hex) {
+  const trimmed = hex.trim().toLowerCase();
+  const isValid = /^(0x)?[0-9a-f]+$/.test(trimmed);
+  if (!isValid) {
+    throw new Error(`Invalid hex string: "${hex}"`);
+  }
+  const normalized = trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+  return BigInt(normalized);
+}
 var MoneyMarketService = class _MoneyMarketService {
   config;
   hubProvider;
@@ -8142,6 +8170,15 @@ var MoneyMarketService = class _MoneyMarketService {
     }
     this.hubProvider = hubProvider;
   }
+  /**
+   * Estimate the gas for a raw transaction.
+   * @param {TxReturnType<T, true>} params - The parameters for the raw transaction.
+   * @param {SpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @returns {Promise<GetEstimateGasReturnType<T>>} A promise that resolves to the gas.
+   */
+  static async estimateGas(params, spokeProvider) {
+    return SpokeService.estimateGas(params, spokeProvider);
+  }
   /**
    * Check if allowance is sufficient for actions on the money market pool
    * @param {MoneyMarketParams} params - Money market params containing token address and amount
@@ -9305,6 +9342,37 @@ var MoneyMarketService = class _MoneyMarketService {
 var EvmSpokeService = class _EvmSpokeService {
   constructor() {
   }
+  /**
+   * Estimates the gas necessary to complete a transaction without submitting it to the network.
+   *
+   * - Docs: https://viem.sh/docs/actions/public/estimateGas
+   * - JSON-RPC Methods: [`eth_estimateGas`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_estimategas)
+   *
+   * @param {EvmRawTransaction} rawTx - The raw transaction to estimate the gas for.
+   * @param {EvmSpokeProvider} spokeProvider - The EVM spoke provider.
+   * @returns {Promise<bigint>} Estimated gas for the transaction.
+   *
+   * @example
+   *
+   * const rawTx: EvmRawTransaction = {
+   *   from: '0x1234...abcd', // sender address
+   *   to: '0xabcd...1234',   // recipient address
+   *   value: 1000000000000000000n, // 1 ETH in wei
+   *   data: '0x', // no calldata
+   * };
+   *
+   * // Assume spokeProvider is an initialized EvmSpokeProvider
+   * const estimatedGas = await EvmSpokeService.estimateGas(rawTx, spokeProvider);
+   * console.log(`Estimated gas: ${estimatedGas}`);
+   */
+  static async estimateGas(rawTx, spokeProvider) {
+    return spokeProvider.publicClient.estimateGas({
+      account: rawTx.from,
+      to: rawTx.to,
+      value: rawTx.value,
+      data: rawTx.data
+    });
+  }
   /**
    * Deposit tokens to the spoke chain.
    * @param {EvmSpokeDepositParams} params - The parameters for the deposit, including the user's address, token address, amount, and additional data.
@@ -9421,6 +9489,25 @@ var EvmSpokeService = class _EvmSpokeService {
 var InjectiveSpokeService = class _InjectiveSpokeService {
   constructor() {
   }
+  /**
+   * Estimate the gas for a transaction.
+   * @param {InjectiveRawTransaction} rawTx - The raw transaction to estimate the gas for.
+   * @param {InjectiveSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @returns {Promise<InjectiveGasEstimate>} The estimated gas for the transaction.
+   */
+  static async estimateGas(rawTx, spokeProvider) {
+    const txRaw = tx_js.TxRaw.fromPartial({
+      bodyBytes: rawTx.signedDoc.bodyBytes,
+      authInfoBytes: rawTx.signedDoc.authInfoBytes,
+      signatures: []
+      // not required for simulation
+    });
+    const { gasInfo } = await spokeProvider.txClient.simulate(txRaw);
+    return {
+      gasWanted: gasInfo.gasWanted,
+      gasUsed: gasInfo.gasUsed
+    };
+  }
   /**
    * Deposit tokens to the spoke chain.
    * @param {InjectiveSpokeDepositParams} params - The parameters for the deposit, including the user's address, token address, amount, and additional data.
@@ -9496,11 +9583,44 @@ var InjectiveSpokeService = class _InjectiveSpokeService {
     return spokeProvider.send_message(sender, dstChainId.toString(), dstAddress, payload, raw);
   }
 };
+
+// src/utils/icon-utils.ts
+async function estimateStepCost(rawTx, debugRpcUrl) {
+  try {
+    const tmpRawTx = { ...rawTx };
+    delete tmpRawTx["stepLimit"];
+    const response = await fetch(debugRpcUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "debug_estimateStep",
+        id: 1234,
+        params: tmpRawTx
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch step cost: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return hexToBigInt(data.result);
+  } catch (e) {
+    console.error("estimateStepCost error:", e);
+    throw e;
+  }
+}
+
+// src/services/spoke/IconSpokeService.ts
 var IconSdk2 = "default" in IconSdkRaw__namespace.default ? IconSdkRaw__namespace.default : IconSdkRaw__namespace;
 var { Converter, CallTransactionBuilder, CallBuilder } = IconSdk2;
 var IconSpokeService = class _IconSpokeService {
   constructor() {
   }
+  static async estimateGas(rawTx, spokeProvider) {
+    return estimateStepCost(rawTx, spokeProvider.debugRpcUrl);
+  }
   /**
    * Deposit tokens to the spoke chain.
    * @param {IconSpokeDepositParams} params - The parameters for the deposit
@@ -9564,15 +9684,16 @@ var IconSpokeService = class _IconSpokeService {
     };
     const value = isNativeToken(spokeProvider.chainConfig.chain.id, token) ? BigIntToHex(amount) : "0x0";
     const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+    const to = isNativeToken(spokeProvider.chainConfig.chain.id, token) ? spokeProvider.chainConfig.addresses.wICX : token;
     const rawTransaction = Converter.toRawTransaction(
-      new CallTransactionBuilder().from(walletAddress).to(token).stepLimit(Converter.toBigNumber("2000000")).nid(spokeProvider.chainConfig.nid).version("0x3").timestamp((/* @__PURE__ */ new Date()).getTime() * 1e3).value(value).method("transfer").params(params).build()
+      new CallTransactionBuilder().from(walletAddress).to(to).stepLimit(Converter.toBigNumber("2000000")).nid(spokeProvider.chainConfig.nid).version("0x3").timestamp((/* @__PURE__ */ new Date()).getTime() * 1e3).value(value).method("transfer").params(params).build()
     );
     if (raw) {
       return rawTransaction;
     }
     return spokeProvider.walletProvider.sendTransaction({
       from: walletAddress,
-      to: isNativeToken(spokeProvider.chainConfig.chain.id, token) ? spokeProvider.chainConfig.addresses.wICX : token,
+      to,
       value,
       nid: spokeProvider.chainConfig.nid,
       method: "transfer",
@@ -9603,15 +9724,13 @@ var IconSpokeService = class _IconSpokeService {
     });
   }
 };
-async function getProvider(base58PublicKey, rpcUrl, wsUrl) {
+async function getProvider(base58PublicKey, rpcUrl) {
   const wallet = {
     publicKey: new web3_js.PublicKey(base58PublicKey),
     signTransaction: () => Promise.reject(),
     signAllTransactions: () => Promise.reject()
   };
-  const connection = new web3_js.Connection(rpcUrl, {
-    wsEndpoint: wsUrl
-  });
+  const connection = new web3_js.Connection(rpcUrl);
   return new anchor__namespace.AnchorProvider(connection, wallet, { commitment: "confirmed" });
 }
 async function getAssetManagerIdl(assetManager, provider) {
@@ -9638,13 +9757,13 @@ async function getConnectionIdl(connection, provider) {
     throw err;
   }
 }
-async function getAssetManagerProgram(base58PublicKey, rpcUrl, wsUrl, assetManager) {
-  const provider = await getProvider(base58PublicKey, rpcUrl, wsUrl);
+async function getAssetManagerProgram(base58PublicKey, rpcUrl, assetManager) {
+  const provider = await getProvider(base58PublicKey, rpcUrl);
   const idl = await getAssetManagerIdl(assetManager, provider);
   return new anchor__namespace.Program(idl, provider);
 }
-async function getConnectionProgram(base58PublicKey, rpcUrl, wsUrl, connection) {
-  const provider = await getProvider(base58PublicKey, rpcUrl, wsUrl);
+async function getConnectionProgram(base58PublicKey, rpcUrl, connection) {
+  const provider = await getProvider(base58PublicKey, rpcUrl);
   const idl = await getConnectionIdl(connection, provider);
   return new anchor__namespace.Program(idl, provider);
 }
@@ -9689,6 +9808,22 @@ var AssetManagerPDA = {
 var SolanaSpokeService = class _SolanaSpokeService {
   constructor() {
   }
+  /**
+   * Estimate the gas for a transaction.
+   * @param {SolanaRawTransaction} rawTx - The raw transaction to estimate the gas for.
+   * @param {SolanaSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @returns {Promise<number | undefined>} The units consumed for the transaction.
+   */
+  static async estimateGas(rawTx, spokeProvider) {
+    const connection = new web3_js.Connection(spokeProvider.chainConfig.rpcUrl, "confirmed");
+    const serializedTxBytes = Buffer.from(rawTx.data, "base64");
+    const versionedTx = web3_js.VersionedTransaction.deserialize(serializedTxBytes);
+    const { value } = await connection.simulateTransaction(versionedTx);
+    if (value.err) {
+      throw new Error(`Failed to simulate transaction: ${JSON.stringify(value.err, null, 2)}`);
+    }
+    return value.unitsConsumed;
+  }
   static async deposit(params, spokeProvider, hubProvider, raw) {
     const userWallet = params.to ?? await EvmWalletAbstraction.getUserHubWalletAddress(
       spokeProvider.chainConfig.chain.id,
@@ -9710,7 +9845,6 @@ var SolanaSpokeService = class _SolanaSpokeService {
     const assetManagerProgram = await getAssetManagerProgram(
       spokeProvider.walletProvider.getWalletBase58PublicKey(),
       spokeProvider.chainConfig.rpcUrl,
-      spokeProvider.chainConfig.wsUrl,
       spokeProvider.chainConfig.addresses.assetManager
     );
     const solToken = new web3_js.PublicKey(Buffer.from(token, "hex"));
@@ -9740,18 +9874,16 @@ var SolanaSpokeService = class _SolanaSpokeService {
     let depositInstruction;
     const amountBN = new BN__default.default(amount);
     const { walletProvider, chainConfig } = spokeProvider;
-    const { rpcUrl, wsUrl, addresses } = chainConfig;
+    const { rpcUrl, addresses } = chainConfig;
     const walletPublicKey = new web3_js.PublicKey(walletProvider.getWalletBase58PublicKey());
     const assetManagerProgram = await getAssetManagerProgram(
       walletProvider.getWalletBase58PublicKey(),
       rpcUrl,
-      wsUrl,
       addresses.assetManager
     );
     const connectionProgram = await getConnectionProgram(
       walletProvider.getWalletBase58PublicKey(),
       rpcUrl,
-      wsUrl,
       addresses.connection
     );
     if (isNative(token)) {
@@ -9826,12 +9958,11 @@ var SolanaSpokeService = class _SolanaSpokeService {
    */
   static async call(dstChainId, dstAddress, payload, spokeProvider, raw) {
     const { walletProvider, chainConfig } = spokeProvider;
-    const { rpcUrl, wsUrl, addresses } = chainConfig;
+    const { rpcUrl, addresses } = chainConfig;
     const walletPublicKey = new web3_js.PublicKey(walletProvider.getWalletBase58PublicKey());
     const connectionProgram = await getConnectionProgram(
       walletProvider.getWalletBase58PublicKey(),
       rpcUrl,
-      wsUrl,
       addresses.connection
     );
     const sendMessageInstruction = await connectionProgram.methods.sendMessage(
@@ -9869,6 +10000,24 @@ var SolanaSpokeService = class _SolanaSpokeService {
 var StellarSpokeService = class _StellarSpokeService {
   constructor() {
   }
+  /**
+   * Estimate the gas for a transaction.
+   * @param rawTx - The raw transaction to estimate the gas for.
+   * @param spokeProvider - The spoke provider.
+   * @returns The estimated gas (minResourceFee) for the transaction.
+   */
+  static async estimateGas(rawTx, spokeProvider) {
+    const network = await spokeProvider.sorobanServer.getNetwork();
+    let tx = stellarSdk.TransactionBuilder.fromXDR(rawTx.data, network.passphrase);
+    if (tx instanceof stellarSdk.FeeBumpTransaction) {
+      tx = tx.innerTransaction;
+    }
+    const simulationForFee = await spokeProvider.sorobanServer.simulateTransaction(tx);
+    if (!stellarSdk.rpc.Api.isSimulationSuccess(simulationForFee)) {
+      throw new Error(`Simulation error: ${JSON.stringify(simulationForFee)}`);
+    }
+    return BigInt(simulationForFee.minResourceFee);
+  }
   static async deposit(params, spokeProvider, hubProvider, raw) {
     const userWallet = params.to ?? await EvmWalletAbstraction.getUserHubWalletAddress(
       spokeProvider.chainConfig.chain.id,
@@ -9923,6 +10072,20 @@ var StellarSpokeService = class _StellarSpokeService {
 var SuiSpokeService = class _SuiSpokeService {
   constructor() {
   }
+  /**
+   * Estimate the gas for a transaction.
+   * @param {SuiRawTransaction} rawTx - The raw transaction to estimate the gas for.
+   * @param {SuiSpokeProvider} spokeProvider - The spoke provider.
+   * @returns {Promise<bigint>} The estimated computation cost.
+   */
+  static async estimateGas(rawTx, spokeProvider) {
+    const txb = transactions.Transaction.fromKind(rawTx.data);
+    const result = await spokeProvider.publicClient.devInspectTransactionBlock({
+      sender: rawTx.from,
+      transactionBlock: txb
+    });
+    return result.effects.gasUsed;
+  }
   /**
    * Deposit tokens to the spoke chain.
    * @param {InjectiveSpokeDepositParams} params - The parameters for the deposit, including the user's address, token address, amount, and additional data.
@@ -9972,7 +10135,7 @@ var SuiSpokeService = class _SuiSpokeService {
   }
   /**
    * Transfers tokens to the hub chain.
-   * @param {TransferToHubParams} params - The parameters for the transfer, including:
+   * @param {SuiTransferToHubParams} params - The parameters for the transfer, including:
    *   - {string} token: The address of the token to transfer (use address(0) for native token).
    *   - {Uint8Array} recipient: The recipient address on the hub chain.
    *   - {string} amount: The amount to transfer.
@@ -10000,6 +10163,38 @@ var SuiSpokeService = class _SuiSpokeService {
 var SonicSpokeService = class _SonicSpokeService {
   constructor() {
   }
+  /**
+   /**
+    * Estimates the gas necessary to complete a transaction without submitting it to the network.
+    *
+    * - Docs: https://viem.sh/docs/actions/public/estimateGas
+    * - JSON-RPC Methods: [`eth_estimateGas`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_estimategas)
+    *
+    * @param {EvmRawTransaction} rawTx - The raw transaction to estimate the gas for.
+    * @param {SonicSpokeProvider} spokeProvider - The EVM spoke provider.
+    * @returns {Promise<bigint>} Estimated gas for the transaction.
+    *
+    * @example
+    *
+    * const rawTx: EvmRawTransaction = {
+    *   from: '0x1234...abcd', // sender address
+    *   to: '0xabcd...1234',   // recipient address
+    *   value: 1000000000000000000n, // 1 ETH in wei
+    *   data: '0x', // no calldata
+    * };
+    *
+    * // Assume spokeProvider is an initialized EvmSpokeProvider
+    * const estimatedGas = await EvmSpokeService.estimateGas(rawTx, spokeProvider);
+    * console.log(`Estimated gas: ${estimatedGas}`);
+    */
+  static async estimateGas(rawTx, spokeProvider) {
+    return spokeProvider.publicClient.estimateGas({
+      account: rawTx.from,
+      to: rawTx.to,
+      value: rawTx.value,
+      data: rawTx.data
+    });
+  }
   /**
    * Get the derived address of a contract deployed with CREATE3.
    * @param address - User's address on the specified chain as hex
@@ -10440,6 +10635,57 @@ function isMoneyMarketRepayUnknownError(error) {
 var SpokeService = class {
   constructor() {
   }
+  /**
+   * Estimate the gas for a raw transaction.
+   * @param {TxReturnType<T, true>} params - The parameters for the raw transaction.
+   * @param {SpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @returns {Promise<GetEstimateGasReturnType<T>>} A promise that resolves to the gas.
+   */
+  static async estimateGas(params, spokeProvider) {
+    if (spokeProvider instanceof EvmSpokeProvider) {
+      return EvmSpokeService.estimateGas(
+        params,
+        spokeProvider
+      );
+    }
+    if (spokeProvider instanceof SonicSpokeProvider) {
+      return SonicSpokeService.estimateGas(
+        params,
+        spokeProvider
+      );
+    }
+    if (spokeProvider instanceof InjectiveSpokeProvider) {
+      return InjectiveSpokeService.estimateGas(
+        params,
+        spokeProvider
+      );
+    }
+    if (spokeProvider instanceof IconSpokeProvider) {
+      return IconSpokeService.estimateGas(
+        params,
+        spokeProvider
+      );
+    }
+    if (spokeProvider instanceof SuiSpokeProvider) {
+      return SuiSpokeService.estimateGas(
+        params,
+        spokeProvider
+      );
+    }
+    if (spokeProvider instanceof SolanaSpokeProvider) {
+      return SolanaSpokeService.estimateGas(
+        params,
+        spokeProvider
+      );
+    }
+    if (spokeProvider instanceof StellarSpokeProvider) {
+      return StellarSpokeService.estimateGas(
+        params,
+        spokeProvider
+      );
+    }
+    throw new Error("Invalid spoke provider");
+  }
   /**
    * Deposit tokens to the spoke chain.
    * @param {GetSpokeDepositParamsType<T extends SpokeProvider>} params - The parameters for the deposit, including the user's address, token address, amount, and additional data.
@@ -11078,6 +11324,15 @@ var SolverService = class {
     }
     this.hubProvider = hubProvider;
   }
+  /**
+   * Estimate the gas for a raw transaction.
+   * @param {TxReturnType<T, true>} params - The parameters for the raw transaction.
+   * @param {SpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @returns {Promise<GetEstimateGasReturnType<T>>} A promise that resolves to the gas.
+   */
+  static async estimateGas(params, spokeProvider) {
+    return SpokeService.estimateGas(params, spokeProvider);
+  }
   /**
    * Request a quote from the solver API
    * @param {SolverIntentQuoteRequest} payload - The solver intent quote request
@@ -12673,6 +12928,7 @@ exports.getSpokeChainIdFromIntentRelayChainId = getSpokeChainIdFromIntentRelayCh
 exports.getSupportedMoneyMarketTokens = getSupportedMoneyMarketTokens;
 exports.getSupportedSolverTokens = getSupportedSolverTokens;
 exports.getTransactionPackets = getTransactionPackets;
+exports.hexToBigInt = hexToBigInt;
 exports.hubAssetToOriginalAssetMap = hubAssetToOriginalAssetMap;
 exports.hubAssets = hubAssets;
 exports.hubVaults = hubVaults;