@sodax/sdk 0.0.1-rc.19 → 0.0.1-rc.20

package/README.md

@@ -254,8 +254,8 @@ const bscSpokeProvider: EvmSpokeProvider = new EvmSpokeProvider(
 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
+- `SolverService.estimateGas()` - for solver/intent operations (reachable through `sodax.solver`)
+- `MoneyMarketService.estimateGas()` - for money market operations (reachable through `sodax.moneyMarket`)
 - `SpokeService.estimateGas()` - for general spoke chain operations
 
 ```typescript

package/dist/index.cjs

@@ -12452,7 +12452,7 @@ var SolverService = class {
    * const fee: bigint = await solverService.getFee(1000000000000000n);
    * console.log('Fee:', fee);
    */
-  async getFee(inputAmount) {
+  getFee(inputAmount) {
     if (!this.config.partnerFee) {
       return 0n;
     }
@@ -12562,29 +12562,37 @@ var SolverService = class {
     }
   }
   /**
-   * Swap is a syntatic sugar for createAndSubmitIntent that creates an intent and submits it to the Solver API and Relayer API
-   * @param {CreateIntentParams} payload - The intent to create
-   * @param {ISpokeProvider} spokeProvider - The spoke provider
-   * @param {number} timeout - The timeout in milliseconds for the transaction. Default is 60 seconds.
-   * @returns {Promise<Result<[SolverExecutionResponse, Intent, PacketData], IntentError<IntentErrorCode>>>} The solver execution response, intent, and packet data
+   * Syntactic sugar for createAndSubmitIntent: creates an intent and submits it to the Solver API and Relayer API.
    *
-   * @example
-   * const payload = {
-   *     "inputToken": "0x2170Ed0880ac9A755fd29B2688956BD959F933F8", // BSC ETH token address
-   *     "outputToken": "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f", // ARB WBTC token address
-   *     "inputAmount": 1000000000000000n, // The amount of input tokens
-   *     "minOutputAmount": 900000000000000n, // min amount you are expecting to receive
-   *     "deadline": 0n, // Optional timestamp after which intent expires (0 = no deadline)
-   *     "allowPartialFill": false, // Whether the intent can be partially filled
-   *     "srcChain": "0x38.bsc", // Chain ID where input tokens originate
-   *     "dstChain": "0xa4b1.arbitrum", // Chain ID where output tokens should be delivered
-   *     "srcAddress": "0x..", // Source address (original address on spoke chain)
-   *     "dstAddress": "0x...", // Destination address (original address on spoke chain)
-   *     "solver": "0x..", // Optional specific solver address (address(0) = any solver)
-   *     "data": "0x..", // Additional arbitrary data
-   * } satisfies CreateIntentParams;
+   * @param {Prettify<SwapParams<S> & OptionalTimeout>} params - Object containing:
+   *   - intentParams: The parameters for creating the intent.
+   *   - spokeProvider: The spoke provider instance.
+   *   - fee: (Optional) Partner fee configuration.
+   *   - timeout: (Optional) Timeout in milliseconds for the transaction (default: 60 seconds).
+   * @returns {Promise<Result<[SolverExecutionResponse, Intent, Hex], IntentError<IntentErrorCode>>>}
+   *   A promise resolving to a Result containing a tuple of SolverExecutionResponse, Intent, and packet data (Hex),
+   *   or an IntentError if the operation fails.
    *
-   * const swapResult = await solverService.swap(payload, spokeProvider);
+   * @example
+   * const swapResult = await solverService.swap({
+   *   intentParams: {
+   *     inputToken: "0x2170Ed0880ac9A755fd29B2688956BD959F933F8",
+   *     outputToken: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
+   *     inputAmount: 1000000000000000n,
+   *     minOutputAmount: 900000000000000n,
+   *     deadline: 0n,
+   *     allowPartialFill: false,
+   *     srcChain: "0x38.bsc",
+   *     dstChain: "0xa4b1.arbitrum",
+   *     srcAddress: "0x..",
+   *     dstAddress: "0x...",
+   *     solver: "0x..",
+   *     data: "0x..",
+   *   },
+   *   spokeProvider,
+   *   fee, // optional
+   *   timeout, // optional
+   * });
    *
    * if (swapResult.ok) {
    *   const [solverExecutionResponse, intent, packetData] = swapResult.value;
@@ -12595,33 +12603,51 @@ var SolverService = class {
    *   // handle error
    * }
    */
-  async swap(payload, spokeProvider, timeout = DEFAULT_RELAY_TX_TIMEOUT) {
-    return this.createAndSubmitIntent(payload, spokeProvider, this.config.partnerFee, timeout);
+  async swap({
+    intentParams: params,
+    spokeProvider,
+    fee = this.config.partnerFee,
+    timeout = DEFAULT_RELAY_TX_TIMEOUT
+  }) {
+    return this.createAndSubmitIntent({
+      intentParams: params,
+      spokeProvider,
+      fee,
+      timeout
+    });
   }
   /**
    * Creates an intent and submits it to the Solver API and Relayer API
-   * @param {CreateIntentParams} payload - The intent to create
-   * @param {ISpokeProvider} spokeProvider - The spoke provider
-   * @param {number} timeout - The timeout in milliseconds for the transaction. Default is 60 seconds.
-   * @returns {Promise<Result<[SolverExecutionResponse, Intent, Hex], IntentError<IntentErrorCode>>>} The solver execution response, intent, and packet data
+   * @param {Prettify<SwapParams<S> & OptionalTimeout>} params - Object containing:
+   *   - intentParams: The parameters for creating the intent.
+   *   - spokeProvider: The spoke provider instance.
+   *   - fee: (Optional) Partner fee configuration.
+   *   - timeout: (Optional) Timeout in milliseconds for the transaction (default: 60 seconds).
+   * @returns {Promise<Result<[SolverExecutionResponse, Intent, Hex], IntentError<IntentErrorCode>>>}
+   *   A promise resolving to a Result containing a tuple of SolverExecutionResponse, Intent, and packet data (Hex),
+   *   or an IntentError if the operation fails.
    *
    * @example
-   * const payload = {
-   *     "inputToken": "0x2170Ed0880ac9A755fd29B2688956BD959F933F8", // BSC ETH token address
-   *     "outputToken": "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f", // ARB WBTC token address
-   *     "inputAmount": 1000000000000000n, // The amount of input tokens
-   *     "minOutputAmount": 900000000000000n, // min amount you are expecting to receive
-   *     "deadline": 0n, // Optional timestamp after which intent expires (0 = no deadline)
-   *     "allowPartialFill": false, // Whether the intent can be partially filled
-   *     "srcChain": "0x38.bsc", // Chain ID where input tokens originate
-   *     "dstChain": "0xa4b1.arbitrum", // Chain ID where output tokens should be delivered
-   *     "srcAddress": "0x..", // Source address (original address on spoke chain)
-   *     "dstAddress": "0x...", // Destination address (original address on spoke chain)
-   *     "solver": "0x..", // Optional specific solver address (address(0) = any solver)
-   *     "data": "0x..", // Additional arbitrary data
-   * } satisfies CreateIntentParams;
+   * const createAndSubmitIntentResult = await solverService.createAndSubmitIntent({
+   *   intentParams: {
+   *     inputToken: "0x2170Ed0880ac9A755fd29B2688956BD959F933F8",
+   *     outputToken: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
+   *     inputAmount: 1000000000000000n,
+   *     minOutputAmount: 900000000000000n,
+   *     deadline: 0n,
+   *     allowPartialFill: false,
+   *     srcChain: "0x38.bsc",
+   *     dstChain: "0xa4b1.arbitrum",
+   *     srcAddress: "0x..",
+   *     dstAddress: "0x...",
+   *     solver: "0x..",
+   *     data: "0x..",
+   *   },
+   *   spokeProvider,
+   *   fee, // optional
+   *   timeout, // optional
+   * });
    *
-   * const createAndSubmitIntentResult = await solverService.createAndSubmitIntent(payload, spokeProvider);
    *
    * if (createAndSubmitIntentResult.ok) {
    *   const [solverExecutionResponse, intent, packetData] = createAndSubmitIntentResult.value;
@@ -12632,17 +12658,27 @@ var SolverService = class {
    *   // handle error
    * }
    */
-  async createAndSubmitIntent(payload, spokeProvider, fee = this.config.partnerFee, timeout = DEFAULT_RELAY_TX_TIMEOUT) {
+  async createAndSubmitIntent({
+    intentParams: params,
+    spokeProvider,
+    fee = this.config.partnerFee,
+    timeout = DEFAULT_RELAY_TX_TIMEOUT
+  }) {
     try {
-      const createIntentResult = await this.createIntent(payload, spokeProvider, fee, false);
+      const createIntentResult = await this.createIntent({
+        intentParams: params,
+        spokeProvider,
+        fee,
+        raw: false
+      });
       if (!createIntentResult.ok) {
         return createIntentResult;
       }
       const [spokeTxHash, intent, data] = createIntentResult.value;
       let intentTxHash = null;
       if (spokeProvider.chainConfig.chain.id !== types.SONIC_MAINNET_CHAIN_ID) {
-        const intentRelayChainId = getIntentRelayChainId(payload.srcChain).toString();
-        const submitPayload = payload.srcChain === types.SOLANA_MAINNET_CHAIN_ID && data ? {
+        const intentRelayChainId = getIntentRelayChainId(params.srcChain).toString();
+        const submitPayload = params.srcChain === types.SOLANA_MAINNET_CHAIN_ID && data ? {
           action: "submit",
           params: {
             chain_id: intentRelayChainId,
@@ -12701,7 +12737,7 @@ var SolverService = class {
         error: {
           code: "UNKNOWN",
           data: {
-            payload,
+            payload: params,
             error
           }
         }
@@ -12709,44 +12745,53 @@ var SolverService = class {
     }
   }
   /**
-   * Check whether assetManager contract is allowed to move the given payload amount
-   * @param {CreateIntentParams} params - The intent to create
-   * @param {SpokeProvider} spokeProvider - The spoke provider
-   * @return {Promise<Result<boolean>>} - valid = true, invalid = false
+   * Check whether the Asset Manager contract is allowed to spend the specified amount of tokens
+   * @param {Prettify<SwapParams<S>} params - Object containing:
+   *   - intentParams: The parameters for creating the intent.
+   *   - spokeProvider: The spoke provider instance.
+   *   - fee: (Optional) Partner fee configuration.
+   * @returns {Promise<Result<boolean>>} - Returns true if allowance is sufficient, false if approval is needed
    *
    * @example
-   * const payload = {
-   *     "inputToken": "0x2170Ed0880ac9A755fd29B2688956BD959F933F8", // BSC ETH token address
-   *     "outputToken": "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f", // ARB WBTC token address
-   *     "inputAmount": 1000000000000000n, // The amount of input tokens
-   *     "minOutputAmount": 900000000000000n, // min amount you are expecting to receive
-   *     "deadline": 0n, // Optional timestamp after which intent expires (0 = no deadline)
-   *     "allowPartialFill": false, // Whether the intent can be partially filled
-   *     "srcChain": "0x38.bsc", // Chain ID where input tokens originate
-   *     "dstChain": "0xa4b1.arbitrum", // Chain ID where output tokens should be delivered
-   *     "srcAddress": "0x..", // Source address (original address on spoke chain)
-   *     "dstAddress": "0x...", // Destination address (original address on spoke chain)
-   *     "solver": "0x..", // Optional specific solver address (address(0) = any solver)
-   *     "data": "0x..", // Additional arbitrary data
+   * const createIntentParams = {
+   *   inputToken: '0x2170Ed0880ac9A755fd29B2688956BD959F933F8', // BSC ETH token address
+   *   outputToken: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f', // ARB WBTC token address
+   *   inputAmount: 1000000000000000n, // The amount of input tokens
+   *   minOutputAmount: 900000000000000n, // min amount you are expecting to receive
+   *   deadline: 0n, // Optional timestamp after which intent expires (0 = no deadline)
+   *   allowPartialFill: false, // Whether the intent can be partially filled
+   *   srcChain: BSC_MAINNET_CHAIN_ID, // Chain ID where input tokens originate
+   *   dstChain: ARBITRUM_MAINNET_CHAIN_ID, // Chain ID where output tokens should be delivered
+   *   srcAddress: '0x..', // Source address (original address on spoke chain)
+   *   dstAddress: '0x...', // Destination address (original address on spoke chain)
+   *   solver: '0x0000000000000000000000000000000000000000', // Optional specific solver address
+   *   data: '0x', // Additional arbitrary data
    * } satisfies CreateIntentParams;
    *
-   * const isAllowanceValid = await solverService.isAllowanceValid(payload, spokeProvider);
+   * const isAllowanceValid = await sodax.solver.isAllowanceValid({
+   *   intentParams: createIntentParams,
+   *   spokeProvider: bscSpokeProvider,
+   * });
    *
-   * if (!allowanceValid.ok) {
+   * if (!isAllowanceValid.ok) {
    *   // Handle error
-   * }
-   *
-   * if (!allowanceValid.value) {
-   *   // Need to approve
+   *   console.error('Failed to check allowance:', isAllowanceValid.error);
+   * } else if (!isAllowanceValid.value) {
+   *   // Need to approve tokens
+   *   console.log('Approval required');
    * }
    */
-  async isAllowanceValid(params, spokeProvider) {
+  async isAllowanceValid({
+    intentParams: params,
+    spokeProvider,
+    fee = this.config.partnerFee
+  }) {
     try {
       if (spokeProvider instanceof EvmSpokeProvider || spokeProvider instanceof SonicSpokeProvider) {
         const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
-        return Erc20Service.isAllowanceValid(
+        return await Erc20Service.isAllowanceValid(
           params.inputToken,
-          params.inputAmount,
+          params.inputAmount + calculateFeeAmount(params.inputAmount, fee),
           walletAddress,
           spokeProvider instanceof EvmSpokeProvider ? spokeProvider.chainConfig.addresses.assetManager : spokeProvider.chainConfig.addresses.walletRouter,
           spokeProvider
@@ -12764,35 +12809,55 @@ var SolverService = class {
     }
   }
   /**
-   * Approve amount spending (currently required for EVM only)
-   * @param token - ERC20 token address
-   * @param amount - Amount to approve
-   * @param spender - Spender address
-   * @param spokeProvider - Spoke provider
-   * @param raw - Whether to return the raw transaction hash instead of the transaction receipt
-   * @returns {Promise<Result<TxReturnType<S, R>>>} - Returns the raw transaction payload or transaction hash
+   * Approve the Asset Manager contract to spend tokens on behalf of the user (required for EVM chains)
+   * @param {Prettify<SwapParams<S> & OptionalRaw<R>>} params - Object containing:
+   *   - intentParams: The parameters for creating the intent.
+   *   - spokeProvider: The spoke provider instance.
+   *   - fee: (Optional) Partner fee configuration.
+   *   - raw: (Optional) Whether to return the raw transaction data instead of executing it
+   * @returns {Promise<Result<TxReturnType<S, R>>>} - Returns transaction hash or raw transaction data
    *
    * @example
-   * const approveResult = await approve(
-   *   '0x...', // ERC20 token address
-   *   1000n, // Amount to approve (in token decimals)
-   *   '0x...', // Spender address (usually the asset manager contract: spokeProvider.chainConfig.addresses.assetManager)
-   *   spokeProvider,
-   *   true // if true, returns raw transaction hash instead of raw transaction
-   * );
+   * const createIntentParams = {
+   *   inputToken: '0x2170Ed0880ac9A755fd29B2688956BD959F933F8', // BSC ETH token address
+   *   outputToken: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f', // ARB WBTC token address
+   *   inputAmount: 1000000000000000n, // The amount of input tokens
+   *   minOutputAmount: 900000000000000n, // min amount you are expecting to receive
+   *   deadline: 0n, // Optional timestamp after which intent expires (0 = no deadline)
+   *   allowPartialFill: false, // Whether the intent can be partially filled
+   *   srcChain: BSC_MAINNET_CHAIN_ID, // Chain ID where input tokens originate
+   *   dstChain: ARBITRUM_MAINNET_CHAIN_ID, // Chain ID where output tokens should be delivered
+   *   srcAddress: '0x..', // Source address (original address on spoke chain)
+   *   dstAddress: '0x...', // Destination address (original address on spoke chain)
+   *   solver: '0x0000000000000000000000000000000000000000', // Optional specific solver address
+   *   data: '0x', // Additional arbitrary data
+   * } satisfies CreateIntentParams;
+   *
+   * const approveResult = await sodax.solver.approve({
+   *   intentParams: createIntentParams,
+   *   spokeProvider: bscSpokeProvider,
+   * });
    *
    * if (!approveResult.ok) {
    *   // Handle error
+   *   console.error('Failed to approve tokens:', approveResult.error);
+   * } else {
+   *   // Transaction hash or raw transaction data
+   *   const txHash = approveResult.value;
+   *   console.log('Approval transaction:', txHash);
    * }
-   *
-   * const txReceipt = approveResult.value;
    */
-  async approve(token, amount, spokeProvider, raw) {
+  async approve({
+    intentParams: params,
+    spokeProvider,
+    fee = this.config.partnerFee,
+    raw
+  }) {
     try {
       if (spokeProvider instanceof EvmSpokeProvider || spokeProvider instanceof SonicSpokeProvider) {
         const result = await Erc20Service.approve(
-          token,
-          amount,
+          params.inputToken,
+          params.inputAmount + calculateFeeAmount(params.inputAmount, fee),
           spokeProvider.chainConfig.addresses.assetManager,
           spokeProvider,
           raw
@@ -12816,11 +12881,12 @@ var SolverService = class {
   /**
    * Creates an intent by handling token approval and intent creation
    * NOTE: This method does not submit the intent to the Solver API
-   * @param {Omit<CreateIntentParams, 'srcAddress'>} params - The intent to create
-   * @param {SpokeProvider} spokeProvider - The spoke provider
-   * @param {boolean} raw - Whether to return the raw transaction
-   * @param {PartnerFee} fee - The fee to apply to the intent
-   * @returns {Promise<Result<[TxReturnType<S, R>, Intent & FeeAmount], IntentError<'CREATION_FAILED'>>>} The encoded contract call
+   * @param {Prettify<SwapParams<S> & OptionalRaw<R>>} params - Object containing:
+   *   - intentParams: The parameters for creating the intent.
+   *   - spokeProvider: The spoke provider instance.
+   *   - fee: (Optional) Partner fee configuration.
+   *   - raw: (Optional) Whether to return the raw transaction data instead of executing it
+   * @returns {Promise<Result<[TxReturnType<S, R>, Intent & FeeAmount], IntentError<'CREATION_FAILED'>>>} The encoded contract call or raw transaction data
    *
    * @example
    * const payload = {
@@ -12838,14 +12904,27 @@ var SolverService = class {
    *     "data": "0x..", // Additional arbitrary data
    * } satisfies CreateIntentParams;
    *
-   * const createIntentResult = await solverService.createIntent(payload, spokeProvider);
+   * const createIntentResult = await solverService.createIntent({
+   *   intentParams: payload,
+   *   spokeProvider,
+   *   fee, // optional
+   *   raw, // optional
+   * });
    *
    * if (createIntentResult.ok) {
    *   const [txResult, intent] = createIntentResult.value;
    *   console.log('Intent:', intent);
-   *
+   *   console.log('Packet data:', packetData);
+   * } else {
+   *   // handle error
+   * }
    */
-  async createIntent(params, spokeProvider, fee, raw) {
+  async createIntent({
+    intentParams: params,
+    spokeProvider,
+    fee = this.config.partnerFee,
+    raw
+  }) {
     invariant2__default.default(
       isValidOriginalAssetAddress(params.srcChain, params.inputToken),
       `Unsupported spoke chain token (params.srcChain): ${params.srcChain}, params.inputToken): ${params.inputToken}`