@sodax/sdk 0.0.1-rc.10 → 0.0.1-rc.11

package/dist/index.cjs

@@ -5187,7 +5187,9 @@ var hubChainConfig = {
     addresses: {
       assetManager: "0x60c5681bD1DB4e50735c4cA3386005A4BA4937C0",
       hubWallet: "0xA0ed3047D358648F2C0583B415CffCA571FDB544",
-      xTokenManager: "0x5bD2843de9D6b0e6A05d0FB742072274EA3C6CA3"
+      xTokenManager: "0x5bD2843de9D6b0e6A05d0FB742072274EA3C6CA3",
+      icxMigration: "0x8Af7cae2c8377BEDD8820A5ad096AaFA29D839cc",
+      sodaToken: "0x8515352CB9832D1d379D52366D1E995ADd358420"
     },
     nativeToken: "0x0000000000000000000000000000000000000000",
     supportedTokens: []
@@ -5712,7 +5714,8 @@ var spokeChainConfig = {
     addresses: {
       assetManager: "cx1be33c283c7dc7617181d1b21a6a2309e71b1ee7",
       connection: "cxe5cdf3b0f26967b0efc72d470d57bbf534268f94",
-      rateLimit: "cxbbdcea9e6757023a046067ba8daa3c4c50304358"
+      rateLimit: "cxbbdcea9e6757023a046067ba8daa3c4c50304358",
+      wICX: "cx3975b43d260fb8ec802cef6e60c2f4d07486f11d"
     },
     chain: {
       id: types.ICON_MAINNET_CHAIN_ID,
@@ -6100,15 +6103,15 @@ var hubAssets = {
       decimal: 6,
       symbol: "USDC",
       name: "USD Coin",
-      vault: "0xdc5B4b00F98347E95b9F94911213DAB4C687e1e3"
+      vault: "0xAbbb91c0617090F0028BDC27597Cd0D038F3A833"
     }
   },
   [types.SOLANA_MAINNET_CHAIN_ID]: {
     [spokeChainConfig[types.SOLANA_MAINNET_CHAIN_ID].supportedTokens.SOL.address]: {
       asset: "0x0c09e69a4528945de6d16c7e469dea6996fdf636",
       decimal: 9,
-      symbol: "USDC",
-      name: "USD Coin",
+      symbol: "SOL",
+      name: "Solana",
       vault: "0xdEa692287E2cE8Cb08FA52917Be0F16b1DACDC87"
     },
     [spokeChainConfig[types.SOLANA_MAINNET_CHAIN_ID].bnUSD]: {
@@ -6119,11 +6122,11 @@ var hubAssets = {
       vault: "0xE801CA34E19aBCbFeA12025378D19c4FBE250131"
     },
     [spokeChainConfig[types.SOLANA_MAINNET_CHAIN_ID].supportedTokens.USDC.address]: {
-      asset: "0x0c09e69a4528945de6d16c7e469dea6996fdf636",
+      asset: "0xC3f020057510ffE10Ceb882e1B48238b43d78a5e",
       decimal: 6,
       symbol: "USDC",
       name: "USD Coin",
-      vault: "0xdEa692287E2cE8Cb08FA52917Be0F16b1DACDC87"
+      vault: "0xAbbb91c0617090F0028BDC27597Cd0D038F3A833"
     }
   },
   [types.ICON_MAINNET_CHAIN_ID]: {
@@ -6134,6 +6137,13 @@ var hubAssets = {
       name: "ICON",
       vault: "0x0000000000000000000000000000000000000000"
     },
+    [spokeChainConfig[types.ICON_MAINNET_CHAIN_ID].addresses.wICX]: {
+      asset: "0xb66cB7D841272AF6BaA8b8119007EdEE35d2C24F",
+      decimal: 18,
+      symbol: "wICX",
+      name: "ICON",
+      vault: "0x0000000000000000000000000000000000000000"
+    },
     [spokeChainConfig[types.ICON_MAINNET_CHAIN_ID].bnUSD]: {
       asset: "0x654dddf32a9a2ac53f5fb54bf1e93f66791f8047",
       decimal: 18,
@@ -6147,8 +6157,7 @@ var DEFAULT_RELAYER_API_ENDPOINT = "https://xcall-relay.nw.iconblockchain.xyz";
 var solverConfig = {
   [types.SONIC_MAINNET_CHAIN_ID]: {
     intentsContract: "0x6382D6ccD780758C5e8A6123c33ee8F4472F96ef",
-    solverApiEndpoint: "https://staging-new-world.iconblockchain.xyz"
-    // TODO replace with mainnet
+    solverApiEndpoint: "https://sodax-solver.iconblockchain.xyz"
   }
 };
 var getSolverConfig = (chainId) => solverConfig[chainId];
@@ -6291,11 +6300,13 @@ var moneyMarketSupportedTokens = {
   ],
   [types.SUI_MAINNET_CHAIN_ID]: [
     spokeChainConfig[types.SUI_MAINNET_CHAIN_ID].supportedTokens.SUI,
-    spokeChainConfig[types.SUI_MAINNET_CHAIN_ID].supportedTokens.bnUSD
+    spokeChainConfig[types.SUI_MAINNET_CHAIN_ID].supportedTokens.bnUSD,
+    spokeChainConfig[types.SUI_MAINNET_CHAIN_ID].supportedTokens.USDC
   ],
   [types.INJECTIVE_MAINNET_CHAIN_ID]: [
     spokeChainConfig[types.INJECTIVE_MAINNET_CHAIN_ID].supportedTokens.INJ,
-    spokeChainConfig[types.INJECTIVE_MAINNET_CHAIN_ID].supportedTokens.bnUSD
+    spokeChainConfig[types.INJECTIVE_MAINNET_CHAIN_ID].supportedTokens.bnUSD,
+    spokeChainConfig[types.INJECTIVE_MAINNET_CHAIN_ID].supportedTokens.USDC
   ],
   [types.NIBIRU_MAINNET_CHAIN_ID]: [],
   [types.SONIC_MAINNET_CHAIN_ID]: [
@@ -9064,10 +9075,7 @@ var IconSpokeService = class _IconSpokeService {
     }
     return spokeProvider.walletProvider.sendTransaction({
       from: walletAddress,
-      to: isNativeToken(spokeProvider.chainConfig.chain.id, token) ? (
-        // wICX address
-        "cx3975b43d260fb8ec802cef6e60c2f4d07486f11d"
-      ) : token,
+      to: isNativeToken(spokeProvider.chainConfig.chain.id, token) ? spokeProvider.chainConfig.addresses.wICX : token,
       value,
       nid: spokeProvider.chainConfig.nid,
       method: "transfer",
@@ -10560,12 +10568,13 @@ var SolverService = class {
   }
   /**
    * Get the status of an intent from Solver API
+   * NOTE: intentHash should be retrieved from relay packet dst_tx_hash property (see createAndSubmitIntent)
    * @param {IntentStatusRequest} intentStatusRequest - The intent status request
    * @returns {Promise<Result<IntentStatusResponse, IntentErrorResponse>>} The intent status response
    *
    * @example
    * const intentStatusRequest = {
-   *     "intentHash": "a0dd7652-b360-4123-ab2d-78cfbcd20c6b"
+   *     "intentHash": "a0dd7652-b360-4123-ab2d-78cfbcd20c6b" // destination tx hash from relay packet
    * } satisfies IntentStatusRequest
    *
    * const response = await solverService.getStatus(intentStatusRequest);
@@ -10789,10 +10798,16 @@ var SolverService = class {
    *
    * const txReceipt = approveResult.value;
    */
-  async approve(token, amount, address, spokeProvider, raw) {
+  async approve(token, amount, spokeProvider, raw) {
     try {
       if (spokeProvider instanceof EvmSpokeProvider || spokeProvider instanceof SonicSpokeProvider) {
-        const result = await Erc20Service.approve(token, amount, address, spokeProvider, raw);
+        const result = await Erc20Service.approve(
+          token,
+          amount,
+          spokeProvider.chainConfig.addresses.assetManager,
+          spokeProvider,
+          raw
+        );
         return {
           ok: true,
           value: result
@@ -10937,6 +10952,937 @@ var SolverService = class {
   }
 };
 
+// src/abis/icxSwap.abi.ts
+var icxSwapAbi = [
+  {
+    type: "constructor",
+    inputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "ICX",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contract IERC20"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "UPGRADE_INTERFACE_VERSION",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getImplementation",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingMigrations",
+    inputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "timestamp",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "reverseSwap",
+    inputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "reverseSwapEnabled",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "sodax",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contract IERC20"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "swap",
+    inputs: [
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Initialized",
+    inputs: [
+      {
+        name: "version",
+        type: "uint64",
+        indexed: false,
+        internalType: "uint64"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferStarted",
+    inputs: [
+      {
+        name: "previousOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      {
+        name: "previousOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PendingMigrationApproved",
+    inputs: [
+      {
+        name: "index",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "user",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PendingMigrationCreated",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "index",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ReverseSwap",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "sodaxAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "ICXAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ReverseSwapToggled",
+    inputs: [
+      {
+        name: "enabled",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Swap",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "ICXAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "sodaxAmount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Upgraded",
+    inputs: [
+      {
+        name: "implementation",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "AddressEmptyCode",
+    inputs: [
+      {
+        name: "target",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC1967InvalidImplementation",
+    inputs: [
+      {
+        name: "implementation",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC1967NonPayable",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "FailedCall",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidInitialization",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NotInitializing",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "OwnableInvalidOwner",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "OwnableUnauthorizedAccount",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ReentrancyGuardReentrantCall",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "SafeERC20FailedOperation",
+    inputs: [
+      {
+        name: "token",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "UUPSUnauthorizedCallContext",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "UUPSUnsupportedProxiableUUID",
+    inputs: [
+      {
+        name: "slot",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ]
+  }
+];
+var IcxMigrationService = class {
+  hubProvider;
+  constructor(hubProvider) {
+    this.hubProvider = hubProvider;
+  }
+  /**
+   * Retrieves the available amount of SODA tokens in the ICX migration contract.
+   * This represents the amount of tokens available for migration.
+   *
+   * @returns The available balance of SODA tokens in the migration contract
+   */
+  async getAvailableAmount() {
+    const balance = await this.hubProvider.publicClient.readContract({
+      address: this.hubProvider.chainConfig.addresses.sodaToken,
+      abi: erc20Abi,
+      functionName: "balanceOf",
+      args: [this.hubProvider.chainConfig.addresses.icxMigration]
+    });
+    return balance;
+  }
+  /**
+   * Generates transaction data for migrating wICX tokens from ICON to the hub chain.
+   * This method creates the necessary contract calls to:
+   * 1. Approve the migration contract to spend the wICX tokens
+   * 2. Execute the migration swap
+   *
+   * @param params - The migration parameters including token address, amount, and recipient
+   * @returns Encoded transaction data for the migration operation
+   * @throws Will throw an error if the hub asset configuration is not found
+   */
+  migrateData(params) {
+    const calls = [];
+    const assetConfig = getHubAssetInfo(types.ICON_MAINNET_CHAIN_ID, params.icx);
+    invariant2__default.default(assetConfig, `hub asset not found for spoke chain token (token): ${params.icx}`);
+    calls.push(
+      Erc20Service.encodeApprove(assetConfig.asset, this.hubProvider.chainConfig.addresses.icxMigration, params.amount)
+    );
+    calls.push(this.encodeMigrate(params.amount, params.to));
+    return encodeContractCalls(calls);
+  }
+  /**
+   * Generates transaction data for migrating back tokens to the ICON  chain.
+   * @param params - The migration parameters including token address, amount, and recipient
+   * @returns Encoded transaction data for the migration operation
+   * @throws Will throw an error if the hub asset configuration is not found
+   */
+  revertMigration(params) {
+    const calls = [];
+    const assetConfig = getHubAssetInfo(types.ICON_MAINNET_CHAIN_ID, params.wICX);
+    invariant2__default.default(assetConfig, `hub asset not found for spoke chain token (token): ${params.wICX}`);
+    calls.push(
+      Erc20Service.encodeApprove(
+        this.hubProvider.chainConfig.addresses.sodaToken,
+        this.hubProvider.chainConfig.addresses.icxMigration,
+        params.amount
+      )
+    );
+    calls.push(this.encodeRevertMigration(params.amount, params.userWallet));
+    calls.push(
+      EvmAssetManagerService.encodeTransfer(
+        assetConfig.asset,
+        params.to,
+        params.amount,
+        this.hubProvider.chainConfig.addresses.assetManager
+      )
+    );
+    return encodeContractCalls(calls);
+  }
+  /**
+   * Encodes a migration transaction for the ICX swap contract.
+   * This creates the contract call data for swapping wICX tokens to SODA tokens.
+   *
+   * @param amount - The amount of wICX tokens to migrate
+   * @param to - The address that will receive the migrated SODA tokens
+   * @returns The encoded contract call for the migration operation
+   */
+  encodeMigrate(amount, to) {
+    return {
+      address: this.hubProvider.chainConfig.addresses.icxMigration,
+      value: 0n,
+      data: viem.encodeFunctionData({
+        abi: icxSwapAbi,
+        functionName: "swap",
+        args: [amount, to]
+      })
+    };
+  }
+  /**
+   * Encodes a revert migration transaction for the ICX swap contract.
+   * This creates the contract call data for swapping SODA tokens to wICX tokens.
+   *
+   * @param amount - The amount of wICX tokens to migrate
+   * @param to - The address that will receive the migrated SODA tokens
+   * @returns The encoded contract call for the migration operation
+   */
+  encodeRevertMigration(amount, to) {
+    return {
+      address: this.hubProvider.chainConfig.addresses.icxMigration,
+      value: 0n,
+      data: viem.encodeFunctionData({
+        abi: icxSwapAbi,
+        functionName: "reverseSwap",
+        args: [amount, to]
+      })
+    };
+  }
+};
+var MigrationService = class {
+  icxMigration;
+  hubProvider;
+  config;
+  constructor(hubProvider, config) {
+    this.hubProvider = hubProvider;
+    this.icxMigration = new IcxMigrationService(hubProvider);
+    this.config = config ?? {
+      relayerApiEndpoint: DEFAULT_RELAYER_API_ENDPOINT
+    };
+  }
+  async migrateData(params) {
+    return this.icxMigration.migrateData(params);
+  }
+  /**
+   * Checks if the allowance is valid for the migration transaction.
+   * @param params - The parameters for the migration transaction.
+   * @param spokeProvider - The spoke provider.
+   * @returns {Promise<Result<boolean>>} - Returns the result of the allowance check or error
+   *
+   * @example
+   * const result = await migrationService.isAllowanceValid(
+   *   {
+   *     token: 'ICX', // Token to migrate
+   *     icx: 'cx...', // Address of the ICX or wICX token to migrate
+   *     amount: 1000n, // Amount to migrate (in ICX decimals, usually 18)
+   *     to: '0x...', // Address to receive the migrated SODA tokens
+   *     action: 'migrate', // Action to perform (migrate or revert)
+   *   },
+   *   spokeProvider, // IconSpokeProvider instance
+   * );
+   *
+   */
+  async isAllowanceValid(params, spokeProvider) {
+    try {
+      if (params.action === "migrate") {
+        invariant2__default.default(params.amount > 0n, "Amount must be greater than 0");
+        invariant2__default.default(viem.isAddress(params.to) || isIconAddress(params.to), "To address is required");
+        invariant2__default.default(
+          spokeProvider instanceof IconSpokeProvider,
+          "Spoke provider must be an instance of IconSpokeProvider"
+        );
+        invariant2__default.default(
+          params.icx.toLowerCase() === spokeProvider.chainConfig.addresses.wICX.toLowerCase() || params.icx.toLowerCase() === spokeProvider.chainConfig.nativeToken.toLowerCase(),
+          "Token must be wICX or native ICX token"
+        );
+        invariant2__default.default(params.token === "ICX", "Token must be ICX");
+        return {
+          ok: true,
+          value: true
+        };
+      }
+      if (params.action === "revert") {
+        invariant2__default.default(params.amount > 0n, "Amount must be greater than 0");
+        invariant2__default.default(viem.isAddress(params.to) || isIconAddress(params.to), "To address is required");
+        invariant2__default.default(
+          spokeProvider instanceof SonicSpokeProvider,
+          "Spoke provider must be an instance of SonicSpokeProvider"
+        );
+        const wallet = await spokeProvider.walletProvider.getWalletAddress();
+        const userRouter = await SonicSpokeService.getUserRouter(wallet, spokeProvider);
+        return await Erc20Service.isAllowanceValid(
+          this.hubProvider.chainConfig.addresses.sodaToken,
+          params.amount,
+          wallet,
+          userRouter,
+          spokeProvider
+        );
+      }
+      return {
+        ok: false,
+        error: new Error("Invalid action")
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error
+      };
+    }
+  }
+  /**
+   * Approves the amount spending for the revert migration transaction.
+   * @param params - The parameters for the revert migration transaction.
+   * @param spokeProvider - The 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
+   *
+   * @example
+   * const result = await migrationService.approve(
+   *   {
+   *     amount: 1000n, // Amount of SODA tokens to revert
+   *     to: 'hx...', // Icon Address to receive the reverted SODA tokens as ICX
+   *     action: 'revert',
+   *   },
+   *   spokeProvider, // SonicSpokeProvider instance
+   *   true // Optional raw flag to return the raw transaction hash instead of the transaction receipt
+   * );
+   *
+   */
+  async approve(params, spokeProvider, raw) {
+    try {
+      if (params.action === "revert") {
+        invariant2__default.default(params.amount > 0n, "Amount must be greater than 0");
+        invariant2__default.default(params.to.length > 0, "To address is required");
+        invariant2__default.default(
+          spokeProvider instanceof SonicSpokeProvider,
+          "Spoke provider must be an instance of SonicSpokeProvider"
+        );
+        const wallet = await spokeProvider.walletProvider.getWalletAddress();
+        const userRouter = await SonicSpokeService.getUserRouter(wallet, spokeProvider);
+        const result = await Erc20Service.approve(
+          this.hubProvider.chainConfig.addresses.sodaToken,
+          params.amount,
+          userRouter,
+          spokeProvider,
+          raw
+        );
+        return {
+          ok: true,
+          value: result
+        };
+      }
+      return {
+        ok: false,
+        error: new Error("Invalid action")
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error
+      };
+    }
+  }
+  /**
+   * Creates a migration intent and submits (relays) it to the hub chain.
+   * @param params - The parameters for the migration transaction.
+   * @param spokeProvider - The spoke provider.
+   * @param timeout - The timeout in milliseconds for the transaction. Default is 60 seconds.
+   * @returns {Promise<Result<[Hex, Hex], MigrationError<'MIGRATION_FAILED'> | MigrationError<'CREATE_MIGRATION_INTENT_FAILED'> | RelayError>>}
+   * Returns a Result containing a tuple of [spokeTxHash, hubTxHash] if successful,
+   * or an error describing why the migration or relay failed.
+   *
+   * @example
+   * const result = await migrationService.createAndSubmitMigrateIntent(
+   *   {
+   *     token: 'ICX', // Token to migrate
+   *     icx: 'cx...', // Address of the ICX or wICX token to migrate
+   *     amount: 1000n, // Amount to migrate (in ICX decimals, usually 18)
+   *     to: '0x...', // Address to receive the migrated SODA tokens
+   *     action: 'migrate',
+   *   },
+   *   spokeProvider, // IconSpokeProvider instance
+   *   30000 // Optional timeout in milliseconds (default: 60000, i.e. 60 seconds)
+   * );
+   *
+   * if (!result.ok) {
+   *   // Handle error
+   * }
+   *
+   * const [
+   *  spokeTxHash, // transaction hash on the spoke chain
+   *  hubTxHash,   // transaction hash on the hub chain (i.e. the transaction that was relayed to the hub)
+   * ] = result.value;
+   * console.log('Migration transaction hashes:', { spokeTxHash, hubTxHash });
+   */
+  async createAndSubmitMigrateIntent(params, spokeProvider, timeout = DEFAULT_RELAY_TX_TIMEOUT) {
+    try {
+      const txResult = await this.createMigrateIntent(params, spokeProvider);
+      if (!txResult.ok) {
+        return {
+          ok: false,
+          error: txResult.error
+        };
+      }
+      const packetResult = await relayTxAndWaitPacket(
+        txResult.value,
+        spokeProvider,
+        this.config.relayerApiEndpoint,
+        timeout
+      );
+      if (!packetResult.ok) {
+        return packetResult;
+      }
+      return { ok: true, value: [txResult.value, packetResult.value.dst_tx_hash] };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "MIGRATION_FAILED",
+          data: {
+            payload: params,
+            error
+          }
+        }
+      };
+    }
+  }
+  /**
+   * Creates a revert migration (SODA to ICX) intent and submits (relays) it to the spoke chain.
+   * @param params - The parameters for the revert migration transaction.
+   * @param spokeProvider - The SonicSpokeProvider instance.
+   * @param timeout - The timeout in milliseconds for the transaction. Default is 60 seconds.
+   *
+   * @returns {Promise<Result<[Hex, Hex], MigrationError<'REVERT_MIGRATION_FAILED'> | MigrationError<'CREATE_REVERT_MIGRATION_INTENT_FAILED'> | RelayError>>}
+   * Returns a Result containing a tuple of [hubTxHash, spokeTxHash] if successful,
+   * or an error describing why the revert migration or relay failed.
+   *
+   *
+   * @example
+   * const result = await migrationService.createAndSubmitRevertMigrationIntent(
+   *   {
+   *     amount: 1000n, // Amount of SODA tokens to revert
+   *     to: 'hx...', // Icon Address to receive the reverted SODA tokens as ICX
+   *     action: 'revert',
+   *   },
+   *   spokeProvider, // SonicSpokeProvider instance
+   *   30000 // Optional timeout in milliseconds (default: 60000, i.e. 60 seconds)
+   * );
+   *
+   * if (!result.ok) {
+   *   // Handle error
+   * }
+   *
+   * const [
+   *  hubTxHash,   // transaction hash on the hub chain
+   *  spokeTxHash, // transaction hash on the spoke chain (i.e. the transaction that was relayed to the spoke)
+   * ] = result.value;
+   * console.log('Revert migration transaction hashes:', { hubTxHash, spokeTxHash });
+   */
+  async createAndSubmitRevertMigrationIntent(params, spokeProvider, timeout = DEFAULT_RELAY_TX_TIMEOUT) {
+    try {
+      const txResult = await this.createRevertMigrationIntent(params, spokeProvider);
+      if (!txResult.ok) {
+        return txResult;
+      }
+      const packetResult = await relayTxAndWaitPacket(
+        txResult.value,
+        spokeProvider,
+        this.config.relayerApiEndpoint,
+        timeout
+      );
+      if (!packetResult.ok) {
+        return packetResult;
+      }
+      return { ok: true, value: [txResult.value, packetResult.value.dst_tx_hash] };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "REVERT_MIGRATION_FAILED",
+          data: {
+            payload: params,
+            error
+          }
+        }
+      };
+    }
+  }
+  /**
+   * Migrates ICX or wICX tokens from ICON to the hub chain.
+   * This function handles the migration of ICX or wICX tokens to SODA tokens on the hub chain.
+   * Note: This function does not relay the transaction to the spoke chain.
+   * You should call the `isAllowanceValid` function before calling this function to check if the allowance is valid.
+   * You should call the `relayTxAndWaitPacket` function after calling this function to relay the transaction to the spoke chain.
+   *
+   * @param {MigrationParams} params - The parameters for the migration transaction.
+   * @param {IconSpokeProvider} spokeProvider - The spoke provider.
+   * @param {boolean} raw - Whether to return the raw transaction hash instead of the transaction receipt
+   * @returns {Promise<Result<TxReturnType<IconSpokeProvider, R>, MigrationError<'CREATE_MIGRATION_INTENT_FAILED'>>>} - Returns the raw transaction payload or transaction hash
+   *
+   * @example
+   * const result = await migrationService.createMigrateIntent(
+   *   {
+   *     icx: 'cx...', // Address of the ICX or wICX token to migrate
+   *     amount: 1000n, // Amount to migrate (in ICX decimals, usually 18)
+   *     to: '0x...', // Address to receive the migrated SODA tokens
+   *   },
+   *   spokeProvider, // IconSpokeProvider instance
+   *   true // Optional raw flag to return the raw transaction hash instead of the transaction receipt
+   * );
+   *
+   * if (!result.ok) {
+   *   // Handle error
+   * }
+   */
+  async createMigrateIntent(params, spokeProvider, raw) {
+    try {
+      invariant2__default.default(params.amount > 0, "Amount must be greater than 0");
+      invariant2__default.default(viem.isAddress(params.to), "Recipient address is required");
+      invariant2__default.default(
+        params.icx.toLowerCase() === spokeProvider.chainConfig.addresses.wICX.toLowerCase() || params.icx.toLowerCase() === spokeProvider.chainConfig.nativeToken.toLowerCase(),
+        "Token must be wICX or native ICX token"
+      );
+      invariant2__default.default(spokeProvider instanceof IconSpokeProvider, "Spoke provider must be an instance of IconSpokeProvider");
+      invariant2__default.default(params.token === "ICX", "Token must be ICX");
+      const availableAmount = await this.icxMigration.getAvailableAmount();
+      if (availableAmount < params.amount) {
+        throw new Error(
+          `Insufficient liquidity. Available: ${availableAmount.toString()}, Requested: ${params.amount.toString()}`
+        );
+      }
+      const migrationData = this.icxMigration.migrateData(params);
+      const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      const txResult = await SpokeService.deposit(
+        {
+          from: walletAddress,
+          token: params.icx,
+          amount: params.amount,
+          data: migrationData
+        },
+        spokeProvider,
+        this.hubProvider,
+        raw
+      );
+      return {
+        ok: true,
+        value: txResult
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "CREATE_MIGRATION_INTENT_FAILED",
+          data: {
+            payload: params,
+            error
+          }
+        }
+      };
+    }
+  }
+  /**
+   * Creates a revert migration intent transaction on the hub chain.
+   * Note: This function does not relay the transaction to the spoke chain.
+   * You should call the `isAllowanceValid` function before calling this function to check if the allowance is valid.
+   * You should call the `relayTxAndWaitPacket` function after calling this function to relay the transaction to the spoke chain.
+   * @param {IcxCreateRevertMigrationParams} - The parameters for the revert migration transaction.
+   * @param {SonicSpokeProvider} spokeProvider - The spoke provider.
+   * @param {boolean} raw - Whether to return the raw transaction hash instead of the transaction receipt
+   * @returns {Promise<Result<TxReturnType<SonicSpokeProvider, R>, MigrationError<'CREATE_REVERT_MIGRATION_INTENT_FAILED'>>>} - Returns the transaction hash or error
+   *
+   * @example
+   * const result = await migrationService.createRevertMigrationIntent(
+   *   {
+   *     amount: 1000n, // Amount of SODA tokens to revert
+   *     to: 'hx...', // Icon Address to receive the reverted SODA tokens as ICX
+   *     action: 'revert',
+   *   },
+   */
+  async createRevertMigrationIntent(params, spokeProvider, raw) {
+    try {
+      const wallet = await spokeProvider.walletProvider.getWalletAddress();
+      const userRouter = await SonicSpokeService.getUserRouter(wallet, spokeProvider);
+      const data = this.icxMigration.revertMigration({
+        wICX: spokeChainConfig[types.ICON_MAINNET_CHAIN_ID].addresses.wICX,
+        amount: params.amount,
+        to: encodeAddress(types.ICON_MAINNET_CHAIN_ID, params.to),
+        userWallet: userRouter
+      });
+      const txResult = await SonicSpokeService.deposit(
+        {
+          from: wallet,
+          token: this.hubProvider.chainConfig.addresses.sodaToken,
+          amount: params.amount,
+          data
+        },
+        spokeProvider,
+        raw
+      );
+      return {
+        ok: true,
+        value: txResult
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "CREATE_REVERT_MIGRATION_INTENT_FAILED",
+          data: {
+            payload: params,
+            error
+          }
+        }
+      };
+    }
+  }
+};
+
 // src/entities/Sodax.ts
 var Sodax = class {
   config;
@@ -10944,6 +11890,8 @@ var Sodax = class {
   // Solver service enabling intent based swaps
   moneyMarket;
   // Money Market service enabling cross-chain lending and borrowing
+  migration;
+  // ICX migration service enabling ICX migration to SODA
   hubProvider;
   // hub provider for the hub chain (e.g. Sonic mainnet)
   relayerApiEndpoint;
@@ -10954,6 +11902,7 @@ var Sodax = class {
     this.hubProvider = new EvmHubProvider(config?.hubProviderConfig);
     this.solver = config && config.solver ? new SolverService(config.solver, this.hubProvider, this.relayerApiEndpoint) : new SolverService(void 0, this.hubProvider, this.relayerApiEndpoint);
     this.moneyMarket = config && config.moneyMarket ? new MoneyMarketService(config.moneyMarket, this.hubProvider, this.relayerApiEndpoint) : new MoneyMarketService(void 0, this.hubProvider, this.relayerApiEndpoint);
+    this.migration = config && config.migration ? new MigrationService(this.hubProvider, config.migration) : new MigrationService(this.hubProvider);
   }
 };
 
@@ -11009,12 +11958,14 @@ exports.HubVaultSymbols = HubVaultSymbols;
 exports.ICON_TX_RESULT_WAIT_MAX_RETRY = ICON_TX_RESULT_WAIT_MAX_RETRY;
 exports.INTENT_RELAY_CHAIN_IDS = INTENT_RELAY_CHAIN_IDS;
 exports.IconSpokeProvider = IconSpokeProvider;
+exports.IcxMigrationService = IcxMigrationService;
 exports.IntentCreatedEventAbi = IntentCreatedEventAbi;
 exports.IntentDataType = IntentDataType;
 exports.IntentErrorCode = IntentErrorCode;
 exports.IntentStatusCode = IntentStatusCode;
 exports.IntentsAbi = IntentsAbi;
 exports.MAX_UINT256 = MAX_UINT256;
+exports.MigrationService = MigrationService;
 exports.MoneyMarketService = MoneyMarketService;
 exports.Sodax = Sodax;
 exports.SolanaSpokeProvider = SolanaSpokeProvider;