@sodax/sdk 0.0.1-rc.30 → 0.0.1-rc.31

package/dist/index.cjs

@@ -6728,8 +6728,8 @@ var spokeChainConfig = {
   [types.SUI_MAINNET_CHAIN_ID]: {
     addresses: {
       connection: "0xf3b1e696a66d02cb776dc15aae73c68bc8f03adcb6ba0ec7f6332d9d90a6a3d2::connectionv3::0x3ee76d13909ac58ae13baab4c9be5a5142818d9a387aed641825e5d4356969bf",
-      assetManagerId: "0x71535403c625ebf004135f52c8691cb0b740f801f19beb43791cb2cecc6f37ae::asset_manager::0xcb7346339340b7f8dea40fcafb70721dc2fcfa7e8626a89fd954d46c1f928b61",
-      assetManager: "0x897f911a4b7691870a1a2513af7e85fdee8de275615c77068fd8b90b8e78c678::asset_manager::0xcb7346339340b7f8dea40fcafb70721dc2fcfa7e8626a89fd954d46c1f928b61",
+      assetManagerConfigId: "0xcb7346339340b7f8dea40fcafb70721dc2fcfa7e8626a89fd954d46c1f928b61",
+      originalAssetManager: "0xa17a409164d1676db71b411ab50813ba2c7dd547d2df538c699049566f1ff922::asset_manager::0xcb7346339340b7f8dea40fcafb70721dc2fcfa7e8626a89fd954d46c1f928b61",
       xTokenManager: "",
       rateLimit: "",
       testToken: ""
@@ -8402,684 +8402,850 @@ var StellarSpokeProvider = class {
     return viem.toHex(Buffer.from(stellaraddress, "hex"));
   }
 };
-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);
-    const tx = new transactions.Transaction();
-    const result = await this.walletProvider.viewContract(
-      tx,
-      assetmanager.packageId,
-      assetmanager.moduleId,
-      "get_token_balance",
-      [tx.object(assetmanager.stateId)],
-      [token]
-    );
-    if (!Array.isArray(result?.returnValues) || !Array.isArray(result.returnValues[0]) || result.returnValues[0][0] === void 0) {
-      throw new Error("Failed to get Balance");
-    }
-    const val = result.returnValues[0][0];
-    const str_u64 = bcs.bcs.U64.parse(Uint8Array.from(val));
-    return BigInt(str_u64);
+var Erc20Service = class {
+  constructor() {
   }
-  async transfer(token, amount, to, data, raw) {
-    const isNative2 = token.toLowerCase() === this.chainConfig.nativeToken.toLowerCase();
-    const tx = new transactions.Transaction();
-    const walletAddress = await this.walletProvider.getWalletAddressBytes();
-    const coin = isNative2 ? await this.getNativeCoin(tx, amount) : await this.getCoin(tx, token, amount, walletAddress);
-    const connection = this.splitAddress(this.chainConfig.addresses.connection);
-    const assetManager = this.splitAddress(this.chainConfig.addresses.assetManager);
-    tx.moveCall({
-      target: `${assetManager.packageId}::${assetManager.moduleId}::transfer`,
-      typeArguments: [token],
-      arguments: [
-        tx.object(assetManager.stateId),
-        tx.object(connection.stateId),
-        // Connection state object
-        coin,
-        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(to)),
-        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(data))
-      ]
-    });
-    if (raw) {
-      tx.setSender(walletAddress);
-      const transactionRaw = await tx.build({
-        client: this.publicClient,
-        onlyTransactionKind: true
+  /**
+   * Check if spender has enough ERC20 allowance for given amount
+   * @param token - ERC20 token address
+   * @param amount - Amount to check allowance for
+   * @param owner - User wallet address
+   * @param spender - Spender address
+   * @param spokeProvider - EVM Spoke provider
+   * @return - True if spender is allowed to spend amount on behalf of owner
+   */
+  static async isAllowanceValid(token, amount, owner, spender, spokeProvider) {
+    try {
+      if (token.toLowerCase() === spokeProvider.chainConfig.nativeToken.toLowerCase()) {
+        return {
+          ok: true,
+          value: true
+        };
+      }
+      const allowedAmount = await spokeProvider.publicClient.readContract({
+        address: token,
+        abi: viem.erc20Abi,
+        functionName: "allowance",
+        args: [owner, spender]
       });
-      const transactionRawBase64String = Buffer.from(transactionRaw).toString("base64");
       return {
-        from: walletAddress,
-        to: `${assetManager.packageId}::${assetManager.moduleId}::transfer`,
-        value: amount,
-        data: transactionRawBase64String
+        ok: true,
+        value: allowedAmount >= amount
       };
-    }
-    return this.walletProvider.signAndExecuteTxn(tx);
-  }
-  async getNativeCoin(tx, amount) {
-    const coin = tx.splitCoins(tx.gas, [tx.pure.u64(amount)])[0];
-    if (coin === void 0) {
-      return Promise.reject(Error("[SuiIntentService.getNativeCoin] coin undefined"));
-    }
-    return coin;
-  }
-  async getCoin(tx, coin, amount, address) {
-    const coins = await this.walletProvider.getCoins(address, coin);
-    const objects = [];
-    let totalAmount = BigInt(0);
-    for (const coin2 of coins.data) {
-      totalAmount += BigInt(coin2.balance);
-      objects.push(coin2.coinObjectId);
-      if (totalAmount >= amount) {
-        break;
-      }
-    }
-    const firstObject = objects[0];
-    if (!firstObject) {
-      throw new Error(`[SuiIntentService.getCoin] Coin=${coin} not found for address=${address} and amount=${amount}`);
-    }
-    if (objects.length > 1) {
-      tx.mergeCoins(firstObject, objects.slice(1));
-    }
-    if (totalAmount === amount) {
-      return tx.object(firstObject);
-    }
-    return tx.splitCoins(firstObject, [amount]);
-  }
-  splitAddress(address) {
-    const parts = address.split("::");
-    if (parts.length === 3) {
-      if (parts[0] && parts[1] && parts[2]) {
-        return { packageId: parts[0], moduleId: parts[1], stateId: parts[2] };
-      }
-      throw new Error("Invalid package address");
-    }
-    throw new Error("Invalid package address");
-  }
-  async sendMessage(dst_chain_id, dst_address, data, raw) {
-    const txb = new transactions.Transaction();
-    const connection = this.splitAddress(this.chainConfig.addresses.connection);
-    txb.moveCall({
-      target: `${connection.packageId}::${connection.moduleId}::send_message_ua`,
-      arguments: [
-        txb.object(connection.stateId),
-        txb.pure.u256(dst_chain_id),
-        txb.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(dst_address)),
-        txb.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(data))
-      ]
-    });
-    const walletAddress = await this.walletProvider.getWalletAddress();
-    if (raw) {
-      txb.setSender(walletAddress);
-      const transactionRaw = await txb.build({
-        client: this.publicClient,
-        onlyTransactionKind: true
-      });
-      const transactionRawBase64String = Buffer.from(transactionRaw).toString("base64");
+    } catch (e) {
       return {
-        from: walletAddress,
-        to: `${connection.packageId}::${connection.moduleId}::send_message_ua`,
-        value: 0n,
-        data: transactionRawBase64String
+        ok: false,
+        error: e
       };
     }
-    return this.walletProvider.signAndExecuteTxn(txb);
   }
-  async configureAssetManagerHub(hubNetworkId, hubAssetManager) {
-    const tx = new transactions.Transaction();
-    const assetmanager = this.splitAddress(this.chainConfig.addresses.assetManager);
-    tx.moveCall({
-      target: `${assetmanager.packageId}::${assetmanager.moduleId}::set_hub_details`,
-      arguments: [tx.object(assetmanager.stateId), tx.pure.u64(hubNetworkId), tx.pure.vector("u8", hubAssetManager)]
-    });
-    const result = await this.walletProvider.signAndExecuteTxn(tx);
-    return result;
+  /**
+   * Approve ERC20 amount spending
+   * @param token - ERC20 token address
+   * @param amount - Amount to approve
+   * @param spender - Spender address
+   * @param provider - EVM Provider
+   */
+  static async approve(token, amount, spender, spokeProvider, raw) {
+    const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+    const rawTx = {
+      from: walletAddress,
+      to: token,
+      value: 0n,
+      data: viem.encodeFunctionData({
+        abi: viem.erc20Abi,
+        functionName: "approve",
+        args: [spender, amount]
+      })
+    };
+    if (raw) {
+      return rawTx;
+    }
+    return spokeProvider.walletProvider.sendTransaction(rawTx);
   }
-  async getWalletAddress() {
-    return this.walletProvider.getWalletAddress();
+  /**
+   * Encodes a transfer transaction for a token.
+   * @param token - The address of the token.
+   * @param to - The address to transfer the token to.
+   * @param amount - The amount of the token to transfer.
+   * @returns The encoded contract call.
+   */
+  static encodeTransfer(token, to, amount) {
+    return {
+      address: token,
+      value: 0n,
+      data: viem.encodeFunctionData({
+        abi: viem.erc20Abi,
+        functionName: "transfer",
+        args: [to, amount]
+      })
+    };
   }
-  async getWalletAddressBytes() {
-    const address = await this.getWalletAddress();
-    return _SuiSpokeProvider.getAddressBCSBytes(address);
+  /**
+   * Encodes a transferFrom transaction for a token.
+   * @param token - The address of the token.
+   * @param from - The address to transfer the token from.
+   * @param to - The address to transfer the token to.
+   * @param amount - The amount of the token to transfer.
+   * @returns The encoded contract call.
+   */
+  static encodeTransferFrom(token, from, to, amount) {
+    return {
+      address: token,
+      value: 0n,
+      data: viem.encodeFunctionData({
+        abi: viem.erc20Abi,
+        functionName: "transferFrom",
+        args: [from, to, amount]
+      })
+    };
   }
-  static getAddressBCSBytes(suiaddress) {
-    return viem.toHex(bcs.bcs.Address.serialize(suiaddress).toBytes());
+  /**
+   * Encodes an approval transaction for a token.
+   * @param token - The address of the token.
+   * @param to - The address to approve the token to.
+   * @param amount - The amount of the token to approve.
+   * @returns The encoded contract call.
+   */
+  static encodeApprove(token, to, amount) {
+    return {
+      address: token,
+      value: 0n,
+      data: viem.encodeFunctionData({
+        abi: viem.erc20Abi,
+        functionName: "approve",
+        args: [to, amount]
+      })
+    };
   }
 };
-
-// src/entities/solana/SolanaSpokeProvider.ts
-var SolanaSpokeProvider = class {
-  walletProvider;
-  chainConfig;
-  constructor(walletProvider, chainConfig) {
-    this.walletProvider = walletProvider;
-    this.chainConfig = chainConfig;
+var EvmVaultTokenService = class {
+  constructor() {
   }
-};
-var solanaSpokeChainConfig = spokeChainConfig[types.SOLANA_MAINNET_CHAIN_ID];
-function getSolanaAddressBytes(address) {
-  return `0x${Buffer.from(address.toBytes()).toString("hex")}`;
-}
-function isNative(address) {
-  if (address.equals(new web3_js.PublicKey(solanaSpokeChainConfig.nativeToken))) {
-    return true;
+  /**
+   * Fetches token information for a specific token in the vault.
+   * @param vault - The address of the vault.
+   * @param token - The address of the token.
+   * @param publicClient - PublicClient<HttpTransport>
+   * @returns Token information as a TokenInfo object.
+   */
+  static async getTokenInfo(vault, token, publicClient) {
+    const [decimals, depositFee, withdrawalFee, maxDeposit, isSupported] = await publicClient.readContract({
+      address: vault,
+      abi: vaultTokenAbi,
+      functionName: "tokenInfo",
+      args: [token]
+    });
+    return { decimals, depositFee, withdrawalFee, maxDeposit, isSupported };
   }
-  return false;
-}
-function convertTransactionInstructionToRaw(instruction) {
-  return {
-    keys: instruction.keys.map((key) => ({
-      pubkey: key.pubkey.toBase58(),
-      isSigner: key.isSigner,
-      isWritable: key.isWritable
-    })),
-    programId: instruction.programId.toBase58(),
-    data: instruction.data
-  };
-}
-
-// src/entities/icon/HanaWalletConnector.ts
-function requestAddress() {
-  return new Promise((resolve) => {
-    const eventHandler = (event) => {
-      const customEvent = event;
-      const response = customEvent.detail;
-      if (isResponseAddressType(response)) {
-        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-        resolve({
-          ok: true,
-          value: response.payload
-        });
-      }
-    };
-    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-    window.dispatchEvent(
-      new CustomEvent("ICONEX_RELAY_REQUEST", {
-        detail: {
-          type: "REQUEST_ADDRESS"
-        }
-      })
-    );
-  });
-}
-function requestSigning(from, hash) {
-  return new Promise((resolve, reject) => {
-    const signRequest = new CustomEvent("ICONEX_RELAY_REQUEST", {
-      detail: {
-        type: "REQUEST_SIGNING",
-        payload: {
-          from,
-          hash
-        }
-      }
+  /**
+   * Retrieves the reserves of the vault.
+   * @param vault - The address of the vault.
+   * @param publicClient - PublicClient<HttpTransport>
+   * @returns An object containing tokens and their balances.
+   */
+  static async getVaultReserves(vault, publicClient) {
+    const [tokens, balances] = await publicClient.readContract({
+      address: vault,
+      abi: vaultTokenAbi,
+      functionName: "getVaultReserves",
+      args: []
     });
-    const eventHandler = (event) => {
-      const customEvent = event;
-      const response = customEvent.detail;
-      if (isResponseSigningType(response)) {
-        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-        resolve({
-          ok: true,
-          value: response.payload
-        });
-      } else if (response.type === "CANCEL_SIGNING") {
-        reject(new Error("CANCEL_SIGNING"));
-      }
-    };
-    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-    window.dispatchEvent(signRequest);
-  });
-}
-function requestJsonRpc(rawTransaction, id = 99999) {
-  return new Promise((resolve, reject) => {
-    const eventHandler = (event) => {
-      const customEvent = event;
-      const { type, payload } = customEvent.detail;
-      if (type === "RESPONSE_JSON-RPC") {
-        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-        if (isJsonRpcPayloadResponse(payload)) {
-          resolve({
-            ok: true,
-            value: payload
-          });
-        } else {
-          reject(new Error("Invalid payload response type (expected JsonRpcPayloadResponse)"));
-        }
-      } else if (type === "CANCEL_JSON-RPC") {
-        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-        reject(new Error("CANCEL_JSON-RPC"));
-      }
+    return {
+      tokens,
+      balances
     };
-    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
-    window.dispatchEvent(
-      new CustomEvent("ICONEX_RELAY_REQUEST", {
-        detail: {
-          type: "REQUEST_JSON-RPC",
-          payload: {
-            jsonrpc: "2.0",
-            method: "icx_sendTransaction",
-            params: rawTransaction,
-            id
-          }
-        }
+  }
+  /**
+   * Retrieves all token information for the vault.
+   * @param vault - The address of the vault.
+   * @param publicClient - PublicClient<HttpTransport>
+   * @returns A promise that resolves to an object containing tokens, their infos, and reserves.
+   */
+  async getAllTokenInfo(vault, publicClient) {
+    const [tokens, infos, reserves] = await publicClient.readContract({
+      address: vault,
+      abi: vaultTokenAbi,
+      functionName: "getAllTokenInfo",
+      args: []
+    });
+    return {
+      tokens,
+      infos,
+      reserves
+    };
+  }
+  /**
+   * Deposits a specified amount of a token into the vault.
+   * @param vault - The address of the vault.
+   * @param token - The address of the token to deposit.
+   * @param amount - The amount of the token to deposit.
+   * @param walletProvider - IEvmWalletProvider
+   * @returns Transaction hash
+   */
+  static async deposit(vault, token, amount, walletProvider) {
+    const from = await walletProvider.getWalletAddress();
+    return walletProvider.sendTransaction({
+      from,
+      to: vault,
+      value: 0n,
+      data: viem.encodeFunctionData({
+        abi: vaultTokenAbi,
+        functionName: "deposit",
+        args: [token, amount]
       })
-    );
-  });
-}
-var Erc20Service = class {
-  constructor() {
+    });
   }
   /**
-   * Check if spender has enough ERC20 allowance for given amount
-   * @param token - ERC20 token address
-   * @param amount - Amount to check allowance for
-   * @param owner - User wallet address
-   * @param spender - Spender address
-   * @param spokeProvider - EVM Spoke provider
-   * @return - True if spender is allowed to spend amount on behalf of owner
+   * Withdraws a specified amount of a token from the vault.
+   * @param vault - The address of the vault.
+   * @param token - The address of the token to withdraw.
+   * @param amount - The amount of the token to withdraw.
+   * @param provider - EvmWalletProvider
+   * @returns Transaction hash
    */
-  static async isAllowanceValid(token, amount, owner, spender, spokeProvider) {
-    try {
-      if (token.toLowerCase() === spokeProvider.chainConfig.nativeToken.toLowerCase()) {
-        return {
-          ok: true,
-          value: true
-        };
-      }
-      const allowedAmount = await spokeProvider.publicClient.readContract({
-        address: token,
-        abi: viem.erc20Abi,
-        functionName: "allowance",
-        args: [owner, spender]
-      });
-      return {
-        ok: true,
-        value: allowedAmount >= amount
-      };
-    } catch (e) {
-      return {
-        ok: false,
-        error: e
-      };
-    }
+  static async withdraw(vault, token, amount, provider) {
+    const from = await provider.getWalletAddress();
+    return provider.sendTransaction({
+      from,
+      to: vault,
+      value: 0n,
+      data: viem.encodeFunctionData({
+        abi: vaultTokenAbi,
+        functionName: "withdraw",
+        args: [token, amount]
+      })
+    });
   }
   /**
-   * Approve ERC20 amount spending
-   * @param token - ERC20 token address
-   * @param amount - Amount to approve
-   * @param spender - Spender address
-   * @param provider - EVM Provider
+   * Encodes the deposit transaction data for the vault.
+   * @param vault - The address of the vault.
+   * @param token - The address of the token to deposit.
+   * @param amount - The amount of the token to deposit.
+   * @returns The encoded contract call data.
    */
-  static async approve(token, amount, spender, spokeProvider, raw) {
-    const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
-    const rawTx = {
-      from: walletAddress,
-      to: token,
+  static encodeDeposit(vault, token, amount) {
+    return {
+      address: vault,
       value: 0n,
       data: viem.encodeFunctionData({
-        abi: viem.erc20Abi,
-        functionName: "approve",
-        args: [spender, amount]
+        abi: vaultTokenAbi,
+        functionName: "deposit",
+        args: [token, amount]
       })
     };
-    if (raw) {
-      return rawTx;
-    }
-    return spokeProvider.walletProvider.sendTransaction(rawTx);
   }
   /**
-   * Encodes a transfer transaction for a token.
-   * @param token - The address of the token.
-   * @param to - The address to transfer the token to.
-   * @param amount - The amount of the token to transfer.
-   * @returns The encoded contract call.
+   * Encodes the withdraw transaction data for the vault.
+   * @param vault - The address of the vault.
+   * @param token - The address of the token to withdraw.
+   * @param amount - The amount of the token to withdraw.
+   * @returns The encoded contract call data.
    */
-  static encodeTransfer(token, to, amount) {
+  static encodeWithdraw(vault, token, amount) {
     return {
-      address: token,
+      address: vault,
       value: 0n,
       data: viem.encodeFunctionData({
-        abi: viem.erc20Abi,
-        functionName: "transfer",
-        args: [to, amount]
+        abi: vaultTokenAbi,
+        functionName: "withdraw",
+        args: [token, amount]
       })
     };
   }
   /**
-   * Encodes a transferFrom transaction for a token.
+   * Translates token amounts from their native decimals to 18 decimals
+   * @param decimals - The number of decimals of the token
+   * @param amount - The amount to translate
+   * @returns The translated amount
+   */
+  static translateIncomingDecimals(decimals, amount) {
+    if (decimals <= 18) {
+      return amount * BigInt(10 ** (18 - decimals));
+    }
+    return amount / BigInt(10 ** (decimals - 18));
+  }
+  /**
+   * Translates token amounts from 18 decimals back to their native decimals
+   * @param decimals - The number of decimals of the token
+   * @param amount - The amount to translate
+   * @returns The translated amount
+   */
+  static translateOutgoingDecimals(decimals, amount) {
+    if (decimals <= 18) {
+      return amount / BigInt(10 ** (18 - decimals));
+    }
+    return amount * BigInt(10 ** (decimals - 18));
+  }
+};
+
+// src/services/hub/EvmAssetManagerService.ts
+var EvmAssetManagerService = class _EvmAssetManagerService {
+  constructor() {
+  }
+  /**
+   * Get asset information for a given asset address
+   * @param asset - The address of the asset contract
+   * @param assetManager - The address of the asset manager contract
+   * @param client - The Viem public client
+   * @returns Object containing chainID and spoke address for the asset
+   */
+  static async getAssetInfo(asset, assetManager, client) {
+    const [chainId, spokeAddress] = await client.readContract({
+      address: assetManager,
+      abi: assetManagerAbi,
+      functionName: "assetInfo",
+      args: [asset]
+    });
+    return {
+      chainId,
+      spokeAddress
+    };
+  }
+  /**
+   * Encodes a transfer transaction for an asset.
    * @param token - The address of the token.
-   * @param from - The address to transfer the token from.
    * @param to - The address to transfer the token to.
    * @param amount - The amount of the token to transfer.
+   * @param assetManager
    * @returns The encoded contract call.
    */
-  static encodeTransferFrom(token, from, to, amount) {
+  static encodeTransfer(token, to, amount, assetManager) {
     return {
-      address: token,
+      address: assetManager,
       value: 0n,
       data: viem.encodeFunctionData({
-        abi: viem.erc20Abi,
-        functionName: "transferFrom",
-        args: [from, to, amount]
+        abi: assetManagerAbi,
+        functionName: "transfer",
+        args: [token, to, amount, "0x"]
       })
     };
   }
   /**
-   * Encodes an approval transaction for a token.
-   * @param token - The address of the token.
-   * @param to - The address to approve the token to.
-   * @param amount - The amount of the token to approve.
-   * @returns The encoded contract call.
+   * Constructs the data for depositing tokens to the spoke chain.
+   * @param {EvmDepositToDataParams} params - The address of the token to deposit.
+   * @param {EvmSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @returns {Hex} Encoded contract calls for the deposit transaction.
+   * @throws Will throw an error if the asset or vault address is not found.
+   */
+  static depositToData(params, spokeChainId) {
+    const calls = [];
+    const assetConfig = getHubAssetInfo(spokeChainId, params.token);
+    if (!assetConfig) {
+      throw new Error("[depositToData] Hub asset not found");
+    }
+    const assetAddress = assetConfig.asset;
+    const vaultAddress = assetConfig.vault;
+    calls.push(Erc20Service.encodeApprove(assetAddress, vaultAddress, params.amount));
+    calls.push(EvmVaultTokenService.encodeDeposit(vaultAddress, assetAddress, params.amount));
+    const translatedAmount = EvmVaultTokenService.translateIncomingDecimals(assetConfig.decimal, params.amount);
+    calls.push(Erc20Service.encodeTransfer(vaultAddress, params.to, translatedAmount));
+    return encodeContractCalls(calls);
+  }
+  /**
+   * Withdraw tokens from the spoke chain.
+   * @param {EvmWithdrawAssetDataParams} params - Parameters for the withdrawal.
+   * @param {EvmSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
+   * @returns {Hex} Encoded contract calls for the withdrawal transaction.
+   * @throws Will throw an error if the asset address is not found.
+   */
+  static withdrawAssetData(params, hubProvider, spokeChainId) {
+    const calls = [];
+    const assetConfig = getHubAssetInfo(spokeChainId, params.token);
+    if (!assetConfig) {
+      throw new Error("[withdrawAssetData] Hub asset not found");
+    }
+    const assetAddress = assetConfig.asset;
+    calls.push(
+      _EvmAssetManagerService.encodeTransfer(
+        assetAddress,
+        params.to,
+        params.amount,
+        hubProvider.chainConfig.addresses.assetManager
+      )
+    );
+    return encodeContractCalls(calls);
+  }
+  /**
+   * Get asset address for a given chain ID and spoke address
+   * @param chainId Chain ID where the asset exists
+   * @param spokeAddress Address of the asset on the spoke chain
+   * @param assetManager Address of the asset manager contract
+   * @param client The Viem public client
+   * @returns The asset's address on the hub chain
    */
-  static encodeApprove(token, to, amount) {
-    return {
-      address: token,
-      value: 0n,
-      data: viem.encodeFunctionData({
-        abi: viem.erc20Abi,
-        functionName: "approve",
-        args: [to, amount]
-      })
-    };
+  async getAssetAddress(chainId, spokeAddress, assetManager, client) {
+    return client.readContract({
+      address: assetManager,
+      abi: assetManagerAbi,
+      functionName: "assets",
+      args: [chainId, spokeAddress]
+    });
   }
 };
-var EvmVaultTokenService = class {
+
+// src/services/hub/EvmWalletAbstraction.ts
+var EvmWalletAbstraction = class {
   constructor() {
   }
   /**
-   * Fetches token information for a specific token in the vault.
-   * @param vault - The address of the vault.
-   * @param token - The address of the token.
-   * @param publicClient - PublicClient<HttpTransport>
-   * @returns Token information as a TokenInfo object.
+   * Get the hub wallet address for a given spoke chain and address.
+   * @param chainId - The spoke chain ID.
+   * @param address - The address on the spoke chain.
+   * @param hubProvider - The hub provider.
+   * @returns The hub wallet address.
    */
-  static async getTokenInfo(vault, token, publicClient) {
-    const [decimals, depositFee, withdrawalFee, maxDeposit, isSupported] = await publicClient.readContract({
-      address: vault,
-      abi: vaultTokenAbi,
-      functionName: "tokenInfo",
-      args: [token]
+  static async getUserHubWalletAddress(chainId, address, hubProvider) {
+    return hubProvider.publicClient.readContract({
+      address: hubProvider.chainConfig.addresses.hubWallet,
+      abi: walletFactoryAbi,
+      functionName: "getDeployedAddress",
+      args: [BigInt(getIntentRelayChainId(chainId)), address]
     });
-    return { decimals, depositFee, withdrawalFee, maxDeposit, isSupported };
   }
-  /**
-   * Retrieves the reserves of the vault.
-   * @param vault - The address of the vault.
-   * @param publicClient - PublicClient<HttpTransport>
-   * @returns An object containing tokens and their balances.
-   */
-  static async getVaultReserves(vault, publicClient) {
-    const [tokens, balances] = await publicClient.readContract({
-      address: vault,
-      abi: vaultTokenAbi,
-      functionName: "getVaultReserves",
-      args: []
-    });
-    return {
-      tokens,
-      balances
-    };
+};
+var SuiSpokeService = class _SuiSpokeService {
+  constructor() {
   }
   /**
-   * Retrieves all token information for the vault.
-   * @param vault - The address of the vault.
-   * @param publicClient - PublicClient<HttpTransport>
-   * @returns A promise that resolves to an object containing tokens, their infos, and reserves.
+   * 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.
    */
-  async getAllTokenInfo(vault, publicClient) {
-    const [tokens, infos, reserves] = await publicClient.readContract({
-      address: vault,
-      abi: vaultTokenAbi,
-      functionName: "getAllTokenInfo",
-      args: []
+  static async estimateGas(rawTx, spokeProvider) {
+    const txb = transactions.Transaction.fromKind(rawTx.data);
+    const result = await spokeProvider.publicClient.devInspectTransactionBlock({
+      sender: rawTx.from,
+      transactionBlock: txb
     });
-    return {
-      tokens,
-      infos,
-      reserves
-    };
+    return result.effects.gasUsed;
   }
   /**
-   * Deposits a specified amount of a token into the vault.
-   * @param vault - The address of the vault.
-   * @param token - The address of the token to deposit.
-   * @param amount - The amount of the token to deposit.
-   * @param walletProvider - IEvmWalletProvider
-   * @returns Transaction hash
+   * 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.
+   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
+   * @param {boolean} raw - The return type raw or just transaction hash
+   * @returns {PromiseSuiTxReturnType<R>} A promise that resolves to the transaction hash or raw transaction base64 string.
    */
-  static async deposit(vault, token, amount, walletProvider) {
-    const from = await walletProvider.getWalletAddress();
-    return walletProvider.sendTransaction({
-      from,
-      to: vault,
-      value: 0n,
-      data: viem.encodeFunctionData({
-        abi: vaultTokenAbi,
-        functionName: "deposit",
-        args: [token, amount]
-      })
-    });
+  static async deposit(params, spokeProvider, hubProvider, raw) {
+    const userWallet = params.to ?? await EvmWalletAbstraction.getUserHubWalletAddress(
+      spokeProvider.chainConfig.chain.id,
+      params.from,
+      hubProvider
+    );
+    return _SuiSpokeService.transfer(
+      {
+        token: params.token,
+        recipient: userWallet,
+        amount: params.amount,
+        data: params.data
+      },
+      spokeProvider,
+      raw
+    );
   }
   /**
-   * Withdraws a specified amount of a token from the vault.
-   * @param vault - The address of the vault.
-   * @param token - The address of the token to withdraw.
-   * @param amount - The amount of the token to withdraw.
-   * @param provider - EvmWalletProvider
-   * @returns Transaction hash
+   * Get the balance of the token in the spoke chain.
+   * @param {Address} token - The address of the token to get the balance of.
+   * @param {SuiSpokeProvider} spokeProvider - The spoke provider.
+   * @returns {Promise<bigint>} The balance of the token.
    */
-  static async withdraw(vault, token, amount, provider) {
-    const from = await provider.getWalletAddress();
-    return provider.sendTransaction({
-      from,
-      to: vault,
-      value: 0n,
-      data: viem.encodeFunctionData({
-        abi: vaultTokenAbi,
-        functionName: "withdraw",
-        args: [token, amount]
-      })
-    });
+  static async getDeposit(token, spokeProvider) {
+    return spokeProvider.getBalance(token);
   }
   /**
-   * Encodes the deposit transaction data for the vault.
-   * @param vault - The address of the vault.
-   * @param token - The address of the token to deposit.
-   * @param amount - The amount of the token to deposit.
-   * @returns The encoded contract call data.
+   * Generate simulation parameters for deposit from SuiSpokeDepositParams.
+   * @param {SuiSpokeDepositParams} params - The deposit parameters.
+   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
+   * @returns {Promise<DepositSimulationParams>} The simulation parameters.
    */
-  static encodeDeposit(vault, token, amount) {
+  static async getSimulateDepositParams(params, spokeProvider, hubProvider) {
+    const to = params.to ?? await EvmWalletAbstraction.getUserHubWalletAddress(
+      spokeProvider.chainConfig.chain.id,
+      params.from,
+      hubProvider
+    );
+    const encoder = new TextEncoder();
     return {
-      address: vault,
-      value: 0n,
-      data: viem.encodeFunctionData({
-        abi: vaultTokenAbi,
-        functionName: "deposit",
-        args: [token, amount]
-      })
+      spokeChainID: spokeProvider.chainConfig.chain.id,
+      token: viem.toHex(encoder.encode(params.token)),
+      from: encodeAddress(spokeProvider.chainConfig.chain.id, params.from),
+      to,
+      amount: params.amount,
+      data: params.data,
+      srcAddress: viem.toHex(encoder.encode(spokeProvider.chainConfig.addresses.originalAssetManager))
     };
   }
   /**
-   * Encodes the withdraw transaction data for the vault.
-   * @param vault - The address of the vault.
-   * @param token - The address of the token to withdraw.
-   * @param amount - The amount of the token to withdraw.
-   * @returns The encoded contract call data.
+   * Calls a contract on the spoke chain using the user's wallet.
+   * @param {HubAddress} from - The address of the user on the spoke chain.
+   * @param {Hex} payload - The payload to send to the contract.
+   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
+   * @param {boolean} raw - The return type raw or just transaction hash
+   * @returns {PromiseSuiTxReturnType<R>} A promise that resolves to the transaction hash or raw transaction base64 string.
    */
-  static encodeWithdraw(vault, token, amount) {
-    return {
-      address: vault,
-      value: 0n,
-      data: viem.encodeFunctionData({
-        abi: vaultTokenAbi,
-        functionName: "withdraw",
-        args: [token, amount]
-      })
-    };
+  static async callWallet(from, payload, spokeProvider, hubProvider, raw) {
+    const relayId = getIntentRelayChainId(hubProvider.chainConfig.chain.id);
+    return _SuiSpokeService.call(BigInt(relayId), from, payload, spokeProvider, raw);
   }
   /**
-   * Translates token amounts from their native decimals to 18 decimals
-   * @param decimals - The number of decimals of the token
-   * @param amount - The amount to translate
-   * @returns The translated amount
+   * Fetch the asset manager config from the spoke chain.
+   * @param {SuiSpokeProvider} suiSpokeProvider - The spoke provider.
+   * @returns {Promise<string>} The asset manager config.
+   */
+  static async fetchAssetManagerAddress(suiSpokeProvider) {
+    const latestPackageId = await _SuiSpokeService.fetchLatestAssetManagerPackageId(suiSpokeProvider);
+    return `${latestPackageId}::asset_manager::${suiSpokeProvider.chainConfig.addresses.assetManagerConfigId}`;
+  }
+  /**
+   * Fetch the latest asset manager package id from the spoke chain.
+   * @param {SuiSpokeProvider} suiSpokeProvider - The spoke provider.
+   * @returns {Promise<string>} The latest asset manager package id.
+   */
+  static async fetchLatestAssetManagerPackageId(suiSpokeProvider) {
+    const configData = await suiSpokeProvider.publicClient.getObject({
+      id: suiSpokeProvider.chainConfig.addresses.assetManagerConfigId,
+      options: {
+        showContent: true
+      }
+    });
+    if (configData.error) {
+      throw new Error(`Failed to fetch asset manager id. Details: ${JSON.stringify(configData.error)}`);
+    }
+    if (!configData.data) {
+      throw new Error("Asset manager id not found (no data)");
+    }
+    if (configData.data.content?.dataType !== "moveObject") {
+      throw new Error("Asset manager id not found (not a move object)");
+    }
+    if (!("latest_package_id" in configData.data.content.fields)) {
+      throw new Error("Asset manager id not found (no latest package id)");
+    }
+    const latestPackageId = configData.data.content.fields["latest_package_id"];
+    if (typeof latestPackageId !== "string") {
+      throw new Error("Asset manager id invalid (latest package id is not a string)");
+    }
+    if (!latestPackageId) {
+      throw new Error("Asset manager id not found (no latest package id)");
+    }
+    return latestPackageId.toString();
+  }
+  /**
+   * Transfers tokens to the hub chain.
+   * @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.
+   *   - {Uint8Array} [data=new Uint8Array([])]: Additional data for the transfer.
+   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @param {boolean} raw - The return type raw or just transaction hash
+   * @returns {PromiseSuiTxReturnType<R>} A promise that resolves to the transaction hash or raw transaction base64 string.
    */
-  static translateIncomingDecimals(decimals, amount) {
-    if (decimals <= 18) {
-      return amount * BigInt(10 ** (18 - decimals));
-    }
-    return amount / BigInt(10 ** (decimals - 18));
+  static async transfer({ token, recipient, amount, data = "0x" }, spokeProvider, raw) {
+    return spokeProvider.transfer(token, amount, viem.fromHex(recipient, "bytes"), viem.fromHex(data, "bytes"), raw);
   }
   /**
-   * Translates token amounts from 18 decimals back to their native decimals
-   * @param decimals - The number of decimals of the token
-   * @param amount - The amount to translate
-   * @returns The translated amount
+   * Sends a message to the hub chain.
+   * @param {bigint} dstChainId - The chain ID of the hub chain.
+   * @param {HubAddress} dstAddress - The address on the hub chain.
+   * @param {Hex} payload - The payload to send.
+   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @param {boolean} raw - The return type raw or just transaction hash
+   * @returns {PromiseSuiTxReturnType<R>} A promise that resolves to the transaction hash or raw transaction base64 string.
    */
-  static translateOutgoingDecimals(decimals, amount) {
-    if (decimals <= 18) {
-      return amount / BigInt(10 ** (18 - decimals));
-    }
-    return amount * BigInt(10 ** (decimals - 18));
+  static async call(dstChainId, dstAddress, payload, spokeProvider, raw) {
+    return spokeProvider.sendMessage(dstChainId, viem.fromHex(dstAddress, "bytes"), viem.fromHex(payload, "bytes"), raw);
   }
 };
 
-// src/services/hub/EvmAssetManagerService.ts
-var EvmAssetManagerService = class _EvmAssetManagerService {
-  constructor() {
+// src/entities/sui/SuiSpokeProvider.ts
+var SuiSpokeProvider = class _SuiSpokeProvider {
+  walletProvider;
+  chainConfig;
+  publicClient;
+  assetManagerAddress;
+  constructor(config, wallet_provider) {
+    this.chainConfig = config;
+    this.walletProvider = wallet_provider;
+    this.publicClient = new client.SuiClient({ url: client.getFullnodeUrl("mainnet") });
   }
-  /**
-   * Get asset information for a given asset address
-   * @param asset - The address of the asset contract
-   * @param assetManager - The address of the asset manager contract
-   * @param client - The Viem public client
-   * @returns Object containing chainID and spoke address for the asset
-   */
-  static async getAssetInfo(asset, assetManager, client) {
-    const [chainId, spokeAddress] = await client.readContract({
-      address: assetManager,
-      abi: assetManagerAbi,
-      functionName: "assetInfo",
-      args: [asset]
+  async getBalance(token) {
+    const assetmanager = this.splitAddress(await this.getAssetManagerAddress());
+    const tx = new transactions.Transaction();
+    const result = await this.walletProvider.viewContract(
+      tx,
+      assetmanager.packageId,
+      assetmanager.moduleId,
+      "get_token_balance",
+      [tx.object(assetmanager.stateId)],
+      [token]
+    );
+    if (!Array.isArray(result?.returnValues) || !Array.isArray(result.returnValues[0]) || result.returnValues[0][0] === void 0) {
+      throw new Error("Failed to get Balance");
+    }
+    const val = result.returnValues[0][0];
+    const str_u64 = bcs.bcs.U64.parse(Uint8Array.from(val));
+    return BigInt(str_u64);
+  }
+  async transfer(token, amount, to, data, raw) {
+    const isNative2 = token.toLowerCase() === this.chainConfig.nativeToken.toLowerCase();
+    const tx = new transactions.Transaction();
+    const walletAddress = await this.walletProvider.getWalletAddressBytes();
+    const coin = isNative2 ? await this.getNativeCoin(tx, amount) : await this.getCoin(tx, token, amount, walletAddress);
+    const connection = this.splitAddress(this.chainConfig.addresses.connection);
+    const assetManager = this.splitAddress(await this.getAssetManagerAddress());
+    tx.moveCall({
+      target: `${assetManager.packageId}::${assetManager.moduleId}::transfer`,
+      typeArguments: [token],
+      arguments: [
+        tx.object(assetManager.stateId),
+        tx.object(connection.stateId),
+        // Connection state object
+        coin,
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(to)),
+        tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(data))
+      ]
     });
-    return {
-      chainId,
-      spokeAddress
-    };
+    if (raw) {
+      tx.setSender(walletAddress);
+      const transactionRaw = await tx.build({
+        client: this.publicClient,
+        onlyTransactionKind: true
+      });
+      const transactionRawBase64String = Buffer.from(transactionRaw).toString("base64");
+      return {
+        from: walletAddress,
+        to: `${assetManager.packageId}::${assetManager.moduleId}::transfer`,
+        value: amount,
+        data: transactionRawBase64String
+      };
+    }
+    return this.walletProvider.signAndExecuteTxn(tx);
   }
-  /**
-   * Encodes a transfer transaction for an asset.
-   * @param token - The address of the token.
-   * @param to - The address to transfer the token to.
-   * @param amount - The amount of the token to transfer.
-   * @param assetManager
-   * @returns The encoded contract call.
-   */
-  static encodeTransfer(token, to, amount, assetManager) {
-    return {
-      address: assetManager,
-      value: 0n,
-      data: viem.encodeFunctionData({
-        abi: assetManagerAbi,
-        functionName: "transfer",
-        args: [token, to, amount, "0x"]
-      })
-    };
+  async getNativeCoin(tx, amount) {
+    const coin = tx.splitCoins(tx.gas, [tx.pure.u64(amount)])[0];
+    if (coin === void 0) {
+      return Promise.reject(Error("[SuiIntentService.getNativeCoin] coin undefined"));
+    }
+    return coin;
   }
-  /**
-   * Constructs the data for depositing tokens to the spoke chain.
-   * @param {EvmDepositToDataParams} params - The address of the token to deposit.
-   * @param {EvmSpokeProvider} spokeProvider - The provider for the spoke chain.
-   * @returns {Hex} Encoded contract calls for the deposit transaction.
-   * @throws Will throw an error if the asset or vault address is not found.
-   */
-  static depositToData(params, spokeChainId) {
-    const calls = [];
-    const assetConfig = getHubAssetInfo(spokeChainId, params.token);
-    if (!assetConfig) {
-      throw new Error("[depositToData] Hub asset not found");
+  async getCoin(tx, coin, amount, address) {
+    const coins = await this.walletProvider.getCoins(address, coin);
+    const objects = [];
+    let totalAmount = BigInt(0);
+    for (const coin2 of coins.data) {
+      totalAmount += BigInt(coin2.balance);
+      objects.push(coin2.coinObjectId);
+      if (totalAmount >= amount) {
+        break;
+      }
     }
-    const assetAddress = assetConfig.asset;
-    const vaultAddress = assetConfig.vault;
-    calls.push(Erc20Service.encodeApprove(assetAddress, vaultAddress, params.amount));
-    calls.push(EvmVaultTokenService.encodeDeposit(vaultAddress, assetAddress, params.amount));
-    const translatedAmount = EvmVaultTokenService.translateIncomingDecimals(assetConfig.decimal, params.amount);
-    calls.push(Erc20Service.encodeTransfer(vaultAddress, params.to, translatedAmount));
-    return encodeContractCalls(calls);
+    const firstObject = objects[0];
+    if (!firstObject) {
+      throw new Error(`[SuiIntentService.getCoin] Coin=${coin} not found for address=${address} and amount=${amount}`);
+    }
+    if (objects.length > 1) {
+      tx.mergeCoins(firstObject, objects.slice(1));
+    }
+    if (totalAmount === amount) {
+      return tx.object(firstObject);
+    }
+    return tx.splitCoins(firstObject, [amount]);
   }
-  /**
-   * Withdraw tokens from the spoke chain.
-   * @param {EvmWithdrawAssetDataParams} params - Parameters for the withdrawal.
-   * @param {EvmSpokeProvider} spokeProvider - The provider for the spoke chain.
-   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
-   * @returns {Hex} Encoded contract calls for the withdrawal transaction.
-   * @throws Will throw an error if the asset address is not found.
-   */
-  static withdrawAssetData(params, hubProvider, spokeChainId) {
-    const calls = [];
-    const assetConfig = getHubAssetInfo(spokeChainId, params.token);
-    if (!assetConfig) {
-      throw new Error("[withdrawAssetData] Hub asset not found");
+  splitAddress(address) {
+    const parts = address.split("::");
+    if (parts.length === 3) {
+      if (parts[0] && parts[1] && parts[2]) {
+        return { packageId: parts[0], moduleId: parts[1], stateId: parts[2] };
+      }
+      throw new Error("Invalid package address");
     }
-    const assetAddress = assetConfig.asset;
-    calls.push(
-      _EvmAssetManagerService.encodeTransfer(
-        assetAddress,
-        params.to,
-        params.amount,
-        hubProvider.chainConfig.addresses.assetManager
-      )
-    );
-    return encodeContractCalls(calls);
+    throw new Error("Invalid package address");
   }
-  /**
-   * Get asset address for a given chain ID and spoke address
-   * @param chainId Chain ID where the asset exists
-   * @param spokeAddress Address of the asset on the spoke chain
-   * @param assetManager Address of the asset manager contract
-   * @param client The Viem public client
-   * @returns The asset's address on the hub chain
-   */
-  async getAssetAddress(chainId, spokeAddress, assetManager, client) {
-    return client.readContract({
-      address: assetManager,
-      abi: assetManagerAbi,
-      functionName: "assets",
-      args: [chainId, spokeAddress]
+  async sendMessage(dst_chain_id, dst_address, data, raw) {
+    const txb = new transactions.Transaction();
+    const connection = this.splitAddress(this.chainConfig.addresses.connection);
+    txb.moveCall({
+      target: `${connection.packageId}::${connection.moduleId}::send_message_ua`,
+      arguments: [
+        txb.object(connection.stateId),
+        txb.pure.u256(dst_chain_id),
+        txb.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(dst_address)),
+        txb.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(data))
+      ]
+    });
+    const walletAddress = await this.walletProvider.getWalletAddress();
+    if (raw) {
+      txb.setSender(walletAddress);
+      const transactionRaw = await txb.build({
+        client: this.publicClient,
+        onlyTransactionKind: true
+      });
+      const transactionRawBase64String = Buffer.from(transactionRaw).toString("base64");
+      return {
+        from: walletAddress,
+        to: `${connection.packageId}::${connection.moduleId}::send_message_ua`,
+        value: 0n,
+        data: transactionRawBase64String
+      };
+    }
+    return this.walletProvider.signAndExecuteTxn(txb);
+  }
+  async configureAssetManagerHub(hubNetworkId, hubAssetManager) {
+    const tx = new transactions.Transaction();
+    const assetmanager = this.splitAddress(await this.getAssetManagerAddress());
+    tx.moveCall({
+      target: `${assetmanager.packageId}::${assetmanager.moduleId}::set_hub_details`,
+      arguments: [tx.object(assetmanager.stateId), tx.pure.u64(hubNetworkId), tx.pure.vector("u8", hubAssetManager)]
     });
+    const result = await this.walletProvider.signAndExecuteTxn(tx);
+    return result;
+  }
+  async getWalletAddress() {
+    return this.walletProvider.getWalletAddress();
+  }
+  async getWalletAddressBytes() {
+    const address = await this.getWalletAddress();
+    return _SuiSpokeProvider.getAddressBCSBytes(address);
+  }
+  static getAddressBCSBytes(suiaddress) {
+    return viem.toHex(bcs.bcs.Address.serialize(suiaddress).toBytes());
+  }
+  async getAssetManagerAddress() {
+    if (!this.assetManagerAddress) {
+      this.assetManagerAddress = await SuiSpokeService.fetchAssetManagerAddress(this);
+    }
+    return this.assetManagerAddress.toString();
   }
 };
 
-// src/services/hub/EvmWalletAbstraction.ts
-var EvmWalletAbstraction = class {
-  constructor() {
-  }
-  /**
-   * Get the hub wallet address for a given spoke chain and address.
-   * @param chainId - The spoke chain ID.
-   * @param address - The address on the spoke chain.
-   * @param hubProvider - The hub provider.
-   * @returns The hub wallet address.
-   */
-  static async getUserHubWalletAddress(chainId, address, hubProvider) {
-    return hubProvider.publicClient.readContract({
-      address: hubProvider.chainConfig.addresses.hubWallet,
-      abi: walletFactoryAbi,
-      functionName: "getDeployedAddress",
-      args: [BigInt(getIntentRelayChainId(chainId)), address]
-    });
+// src/entities/solana/SolanaSpokeProvider.ts
+var SolanaSpokeProvider = class {
+  walletProvider;
+  chainConfig;
+  constructor(walletProvider, chainConfig) {
+    this.walletProvider = walletProvider;
+    this.chainConfig = chainConfig;
   }
 };
+var solanaSpokeChainConfig = spokeChainConfig[types.SOLANA_MAINNET_CHAIN_ID];
+function getSolanaAddressBytes(address) {
+  return `0x${Buffer.from(address.toBytes()).toString("hex")}`;
+}
+function isNative(address) {
+  if (address.equals(new web3_js.PublicKey(solanaSpokeChainConfig.nativeToken))) {
+    return true;
+  }
+  return false;
+}
+function convertTransactionInstructionToRaw(instruction) {
+  return {
+    keys: instruction.keys.map((key) => ({
+      pubkey: key.pubkey.toBase58(),
+      isSigner: key.isSigner,
+      isWritable: key.isWritable
+    })),
+    programId: instruction.programId.toBase58(),
+    data: instruction.data
+  };
+}
+
+// src/entities/icon/HanaWalletConnector.ts
+function requestAddress() {
+  return new Promise((resolve) => {
+    const eventHandler = (event) => {
+      const customEvent = event;
+      const response = customEvent.detail;
+      if (isResponseAddressType(response)) {
+        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+        resolve({
+          ok: true,
+          value: response.payload
+        });
+      }
+    };
+    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.dispatchEvent(
+      new CustomEvent("ICONEX_RELAY_REQUEST", {
+        detail: {
+          type: "REQUEST_ADDRESS"
+        }
+      })
+    );
+  });
+}
+function requestSigning(from, hash) {
+  return new Promise((resolve, reject) => {
+    const signRequest = new CustomEvent("ICONEX_RELAY_REQUEST", {
+      detail: {
+        type: "REQUEST_SIGNING",
+        payload: {
+          from,
+          hash
+        }
+      }
+    });
+    const eventHandler = (event) => {
+      const customEvent = event;
+      const response = customEvent.detail;
+      if (isResponseSigningType(response)) {
+        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+        resolve({
+          ok: true,
+          value: response.payload
+        });
+      } else if (response.type === "CANCEL_SIGNING") {
+        reject(new Error("CANCEL_SIGNING"));
+      }
+    };
+    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.dispatchEvent(signRequest);
+  });
+}
+function requestJsonRpc(rawTransaction, id = 99999) {
+  return new Promise((resolve, reject) => {
+    const eventHandler = (event) => {
+      const customEvent = event;
+      const { type, payload } = customEvent.detail;
+      if (type === "RESPONSE_JSON-RPC") {
+        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+        if (isJsonRpcPayloadResponse(payload)) {
+          resolve({
+            ok: true,
+            value: payload
+          });
+        } else {
+          reject(new Error("Invalid payload response type (expected JsonRpcPayloadResponse)"));
+        }
+      } else if (type === "CANCEL_JSON-RPC") {
+        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+        reject(new Error("CANCEL_JSON-RPC"));
+      }
+    };
+    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.dispatchEvent(
+      new CustomEvent("ICONEX_RELAY_REQUEST", {
+        detail: {
+          type: "REQUEST_JSON-RPC",
+          payload: {
+            jsonrpc: "2.0",
+            method: "icx_sendTransaction",
+            params: rawTransaction,
+            id
+          }
+        }
+      })
+    );
+  });
+}
 var EvmSpokeService = class _EvmSpokeService {
   constructor() {
   }
@@ -9941,121 +10107,6 @@ 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.
-   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
-   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
-   * @param {boolean} raw - The return type raw or just transaction hash
-   * @returns {PromiseSuiTxReturnType<R>} A promise that resolves to the transaction hash or raw transaction base64 string.
-   */
-  static async deposit(params, spokeProvider, hubProvider, raw) {
-    const userWallet = params.to ?? await EvmWalletAbstraction.getUserHubWalletAddress(
-      spokeProvider.chainConfig.chain.id,
-      params.from,
-      hubProvider
-    );
-    return _SuiSpokeService.transfer(
-      {
-        token: params.token,
-        recipient: userWallet,
-        amount: params.amount,
-        data: params.data
-      },
-      spokeProvider,
-      raw
-    );
-  }
-  /**
-   * Get the balance of the token in the spoke chain.
-   * @param {Address} token - The address of the token to get the balance of.
-   * @param {SuiSpokeProvider} spokeProvider - The spoke provider.
-   * @returns {Promise<bigint>} The balance of the token.
-   */
-  static async getDeposit(token, spokeProvider) {
-    return spokeProvider.getBalance(token);
-  }
-  /**
-   * Generate simulation parameters for deposit from SuiSpokeDepositParams.
-   * @param {SuiSpokeDepositParams} params - The deposit parameters.
-   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
-   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
-   * @returns {Promise<DepositSimulationParams>} The simulation parameters.
-   */
-  static async getSimulateDepositParams(params, spokeProvider, hubProvider) {
-    const to = params.to ?? await EvmWalletAbstraction.getUserHubWalletAddress(
-      spokeProvider.chainConfig.chain.id,
-      params.from,
-      hubProvider
-    );
-    const encoder = new TextEncoder();
-    return {
-      spokeChainID: spokeProvider.chainConfig.chain.id,
-      token: viem.toHex(encoder.encode(params.token)),
-      from: encodeAddress(spokeProvider.chainConfig.chain.id, params.from),
-      to,
-      amount: params.amount,
-      data: params.data,
-      srcAddress: viem.toHex(encoder.encode(spokeProvider.chainConfig.addresses.assetManagerId))
-    };
-  }
-  /**
-   * Calls a contract on the spoke chain using the user's wallet.
-   * @param {HubAddress} from - The address of the user on the spoke chain.
-   * @param {Hex} payload - The payload to send to the contract.
-   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
-   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
-   * @param {boolean} raw - The return type raw or just transaction hash
-   * @returns {PromiseSuiTxReturnType<R>} A promise that resolves to the transaction hash or raw transaction base64 string.
-   */
-  static async callWallet(from, payload, spokeProvider, hubProvider, raw) {
-    const relayId = getIntentRelayChainId(hubProvider.chainConfig.chain.id);
-    return _SuiSpokeService.call(BigInt(relayId), from, payload, spokeProvider, raw);
-  }
-  /**
-   * Transfers tokens to the hub chain.
-   * @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.
-   *   - {Uint8Array} [data=new Uint8Array([])]: Additional data for the transfer.
-   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
-   * @param {boolean} raw - The return type raw or just transaction hash
-   * @returns {PromiseSuiTxReturnType<R>} A promise that resolves to the transaction hash or raw transaction base64 string.
-   */
-  static async transfer({ token, recipient, amount, data = "0x" }, spokeProvider, raw) {
-    return spokeProvider.transfer(token, amount, viem.fromHex(recipient, "bytes"), viem.fromHex(data, "bytes"), raw);
-  }
-  /**
-   * Sends a message to the hub chain.
-   * @param {bigint} dstChainId - The chain ID of the hub chain.
-   * @param {HubAddress} dstAddress - The address on the hub chain.
-   * @param {Hex} payload - The payload to send.
-   * @param {SuiSpokeProvider} spokeProvider - The provider for the spoke chain.
-   * @param {boolean} raw - The return type raw or just transaction hash
-   * @returns {PromiseSuiTxReturnType<R>} A promise that resolves to the transaction hash or raw transaction base64 string.
-   */
-  static async call(dstChainId, dstAddress, payload, spokeProvider, raw) {
-    return spokeProvider.sendMessage(dstChainId, viem.fromHex(dstAddress, "bytes"), viem.fromHex(payload, "bytes"), raw);
-  }
-};
 var SonicSpokeService = class _SonicSpokeService {
   constructor() {
   }
@@ -16711,6 +16762,7 @@ exports.SonicSpokeService = SonicSpokeService;
 exports.SpokeService = SpokeService;
 exports.StellarSpokeProvider = StellarSpokeProvider;
 exports.SuiSpokeProvider = SuiSpokeProvider;
+exports.SuiSpokeService = SuiSpokeService;
 exports.SupportedMigrationTokens = SupportedMigrationTokens;
 exports.USD_DECIMALS = USD_DECIMALS;
 exports.UiPoolDataProviderService = UiPoolDataProviderService;