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

package/dist/index.mjs

@@ -12425,7 +12425,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;
     }
@@ -12535,29 +12535,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;
@@ -12568,33 +12576,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;
@@ -12605,17 +12631,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 !== SONIC_MAINNET_CHAIN_ID) {
-        const intentRelayChainId = getIntentRelayChainId(payload.srcChain).toString();
-        const submitPayload = payload.srcChain === SOLANA_MAINNET_CHAIN_ID && data ? {
+        const intentRelayChainId = getIntentRelayChainId(params.srcChain).toString();
+        const submitPayload = params.srcChain === SOLANA_MAINNET_CHAIN_ID && data ? {
           action: "submit",
           params: {
             chain_id: intentRelayChainId,
@@ -12674,7 +12710,7 @@ var SolverService = class {
         error: {
           code: "UNKNOWN",
           data: {
-            payload,
+            payload: params,
             error
           }
         }
@@ -12682,44 +12718,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
@@ -12737,35 +12782,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
@@ -12789,11 +12854,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 = {
@@ -12811,14 +12877,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(
       isValidOriginalAssetAddress(params.srcChain, params.inputToken),
       `Unsupported spoke chain token (params.srcChain): ${params.srcChain}, params.inputToken): ${params.inputToken}`