@sodax/sdk 1.2.6-beta → 1.3.0-beta

package/dist/index.cjs

@@ -13,6 +13,7 @@ var bcs = require('@mysten/sui/bcs');
 var client = require('@mysten/sui/client');
 var transactions = require('@mysten/sui/transactions');
 var stellarSdk = require('@stellar/stellar-sdk');
+var nearApiJs = require('near-api-js');
 var BigNumber4 = require('bignumber.js');
 var coreProtoTs = require('@injectivelabs/core-proto-ts');
 var rlp = require('rlp');
@@ -8627,6 +8628,186 @@ var StellarSpokeProvider = class extends StellarBaseSpokeProvider {
     return viem.toHex(Buffer.from(stellaraddress, "hex"));
   }
 };
+var NearBaseSpokeProvider = class {
+  chainConfig;
+  rpcProvider;
+  constructor(chainConfig) {
+    this.chainConfig = chainConfig;
+    this.rpcProvider = new nearApiJs.JsonRpcProvider({ url: chainConfig.rpcUrl });
+  }
+  /**
+   * Waits for a NEAR transaction to reach finality.
+   *
+   * Uses the RPC `waitUntil: 'FINAL'` long-polling mode, which blocks server-side
+   * until the transaction is finalized. Retries are only for transient network errors
+   * (e.g. connection resets, DNS failures, timeouts). A successful RPC response —
+   * whether success or failure — returns immediately without further retries.
+   */
+  static async waitForTransaction(txHash, accountId, rpcProvider, maxRetries = 3, retryDelay = 1e3) {
+    for (let retry2 = 0; retry2 <= maxRetries; retry2++) {
+      try {
+        const outcome = await rpcProvider.viewTransactionStatus({ txHash, accountId, waitUntil: "FINAL" });
+        const status = outcome?.status;
+        if (status && ("SuccessValue" in status || "SuccessReceiptId" in status)) {
+          return { status: "success" };
+        }
+        if (status && "Failure" in status) {
+          return { status: "failure", failure: status.Failure };
+        }
+        if (retry2 < maxRetries) {
+          await sleep(retryDelay);
+        }
+      } catch {
+        if (retry2 < maxRetries) {
+          await sleep(retryDelay);
+        }
+      }
+    }
+    throw new Error(`NEAR transaction ${txHash} was not confirmed after ${maxRetries} retries`);
+  }
+  queryContract(contractId, method, args) {
+    return this.rpcProvider.callFunction({ contractId, method, args });
+  }
+  async getRawTransaction(params) {
+    throw new Error("Not implemented");
+  }
+  transfer(params, deposit = BigInt("1"), gas = BigInt("300000000000000")) {
+    if (this.isNative(params.token)) {
+      deposit = BigInt(params.amount);
+      return this.depositNear(params, deposit, gas);
+    }
+    return this.depositToken(params, deposit, gas);
+  }
+  depositNear(params, deposit, gas) {
+    return this.getRawTransaction({
+      contractId: this.chainConfig.addresses.assetManager,
+      method: "transfer",
+      args: { to: params.to, amount: params.amount, data: params.data },
+      deposit,
+      gas
+    });
+  }
+  depositToken(params, deposit, gas) {
+    return this.getRawTransaction({
+      contractId: params.token,
+      method: "ft_transfer_call",
+      args: {
+        receiver_id: this.chainConfig.addresses.assetManager,
+        amount: params.amount.toString(),
+        memo: "",
+        msg: JSON.stringify({
+          to: params.to,
+          data: params.data
+        })
+      },
+      deposit,
+      gas
+    });
+  }
+  sendMessage(params, deposit = BigInt("0"), gas = BigInt("300000000000000")) {
+    return this.getRawTransaction({
+      contractId: this.chainConfig.addresses.connection,
+      method: "send_message",
+      args: params,
+      deposit,
+      gas
+    });
+  }
+  isNative(token) {
+    return token === "NEAR";
+  }
+  async getBalance(token) {
+    if (this.isNative(token)) {
+      return this.queryContract(this.chainConfig.addresses.assetManager, "get_balance", {});
+    }
+    return this.queryContract(token, "ft_balance_of", {
+      account_id: this.chainConfig.addresses.assetManager
+    });
+  }
+  async getRateLimit(token) {
+    const res = await this.queryContract(this.chainConfig.addresses.rateLimit, "get_rate_limit", {
+      token
+    });
+    if (res == null || res === void 0) {
+      return {
+        maxAvailable: 0,
+        available: 0,
+        ratePerSecond: 0
+      };
+    }
+    return {
+      maxAvailable: res.max_available,
+      available: res.available,
+      ratePerSecond: res.rate_per_second
+    };
+  }
+  toFillIntent(fillData) {
+    return {
+      amount: fillData.amount.toString(),
+      fill_id: fillData.fill_id.toString(),
+      intent_hash: Array.from(viem.fromHex(fillData.intent_hash, "bytes")),
+      receiver: Array.from(Buffer.from(fillData.receiver, "utf-8")),
+      solver: Array.from(viem.fromHex(fillData.solver, "bytes")),
+      token: Array.from(Buffer.from(fillData.token, "utf-8"))
+    };
+  }
+  async fillIntent(fillData, deposit = BigInt("1"), gas = BigInt("300000000000000")) {
+    if (this.isNative(fillData.token)) {
+      deposit = BigInt(fillData.amount);
+      return this.getRawTransaction({
+        contractId: this.chainConfig.addresses.intentFiller,
+        method: "fill_intent",
+        args: { fill: this.toFillIntent(fillData) },
+        deposit,
+        gas
+      });
+    }
+    return this.getRawTransaction({
+      contractId: fillData.token,
+      method: "ft_transfer_call",
+      args: {
+        receiver_id: this.chainConfig.addresses.intentFiller,
+        amount: fillData.amount.toString(),
+        memo: "",
+        msg: JSON.stringify(this.toFillIntent(fillData))
+      },
+      deposit,
+      gas
+    });
+  }
+};
+var NearSpokeProvider = class extends NearBaseSpokeProvider {
+  walletProvider;
+  constructor(walletProvider, chainConfig) {
+    super(chainConfig);
+    this.walletProvider = walletProvider;
+  }
+  async submit(transaction) {
+    return await this.walletProvider.signAndSubmitTxn(transaction);
+  }
+  async getRawTransaction(params) {
+    return {
+      signerId: await this.walletProvider.getWalletAddress(),
+      params
+    };
+  }
+};
+var NearRawSpokeProvider = class extends NearBaseSpokeProvider {
+  walletProvider;
+  raw = true;
+  constructor(chainConfig, walletAddress) {
+    super(chainConfig);
+    this.walletProvider = {
+      getWalletAddress: async () => walletAddress
+    };
+  }
+  async getRawTransaction(params) {
+    return {
+      signerId: await this.walletProvider.getWalletAddress(),
+      params
+    };
+  }
+};
 var BigNumberZeroDecimal = BigNumber4.BigNumber.clone({
   DECIMAL_PLACES: 0,
   ROUNDING_MODE: BigNumber4.BigNumber.ROUND_DOWN
@@ -12157,6 +12338,159 @@ var SolanaSpokeService = class _SolanaSpokeService {
     }
   }
 };
+var NearSpokeService = class _NearSpokeService {
+  constructor() {
+  }
+  /**
+   * Deposit tokens to the spoke chain.
+   * @param {CWSpokeDepositParams} params - The parameters for the deposit, including the user's address, token address, amount, and additional data.
+   * @param {CWSpokeProvider} 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 {PromiseNearTxReturnType<R>} A promise that resolves to the transaction hash.
+   */
+  static async deposit(params, spokeProvider, hubProvider, raw) {
+    const userWallet = params.to ?? await EvmWalletAbstraction.getUserHubWalletAddress(
+      spokeProvider.chainConfig.chain.id,
+      viem.toHex(Buffer.from(params.from, "utf-8")),
+      hubProvider
+    );
+    const txn = await spokeProvider.transfer({
+      token: params.token,
+      to: Array.from(viem.fromHex(userWallet, "bytes")),
+      amount: params.amount.toString(),
+      data: Array.from(viem.fromHex(params.data, "bytes"))
+    });
+    if (raw || isNearRawSpokeProvider(spokeProvider)) {
+      return txn;
+    }
+    const hash = await spokeProvider.submit(txn);
+    return 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 {CWSpokeProvider} spokeProvider - The spoke provider.
+   * @returns {Promise<bigint>} The balance of the token.
+   */
+  static async getDeposit(token, spokeProvider) {
+    const bal = await spokeProvider.getBalance(token);
+    return BigInt(bal);
+  }
+  /**
+   * Generate simulation parameters for deposit from NearSpokeDepositParams.
+   * @param {NearSpokeDepositParams} params - The deposit parameters.
+   * @param {NearSpokeProviderType} 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,
+      encodeAddress(spokeProvider.chainConfig.chain.id, params.from),
+      hubProvider
+    );
+    return {
+      spokeChainID: spokeProvider.chainConfig.chain.id,
+      token: encodeAddress(spokeProvider.chainConfig.chain.id, params.token),
+      from: encodeAddress(spokeProvider.chainConfig.chain.id, params.from),
+      to,
+      amount: params.amount,
+      data: params.data,
+      srcAddress: encodeAddress(spokeProvider.chainConfig.chain.id, spokeProvider.chainConfig.addresses.assetManager)
+    };
+  }
+  /**
+   * Calls a contract on the spoke chain using the user's wallet.
+   * @param {HubAddress} from - The address of the user on the hub chain.
+   * @param {Hex} payload - The payload to send to the contract.
+   * @param {CWSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @param {EvmHubProvider} hubProvider - The provider for the hub chain.
+   * @returns {Promise<TxReturnType<S, R>>} A promise that resolves to the transaction hash.
+   */
+  static async callWallet(from, payload, spokeProvider, hubProvider, raw) {
+    const relayId = types.getIntentRelayChainId(hubProvider.chainConfig.chain.id);
+    return _NearSpokeService.call(BigInt(relayId), from, payload, spokeProvider, raw);
+  }
+  /**
+   * Sends a message to the hub chain.
+   * @param {bigint} dstChainId - The chain ID of the hub chain.
+   * @param {Address} dstAddress - The address on the hub chain.
+   * @param {Hex} payload - The payload to send.
+   * @param {CWSpokeProvider} spokeProvider - The provider for the spoke chain.
+   * @returns {Promise<TxReturnType<S, R>>} A promise that resolves to the transaction hash.
+   */
+  static async call(dstChainId, dstAddress, payload, spokeProvider, raw) {
+    const txn = await spokeProvider.sendMessage({
+      dst_address: Array.from(viem.fromHex(dstAddress, "bytes")),
+      dst_chain_id: Number.parseInt(dstChainId.toString()),
+      payload: Array.from(viem.fromHex(payload, "bytes"))
+    });
+    if (raw || isNearRawSpokeProvider(spokeProvider)) {
+      return txn;
+    }
+    const hash = await spokeProvider.submit(txn);
+    return hash;
+  }
+  /**
+   * Get Max Withdrawable Balance for the token.
+   * @param {Address} token - The address of the token to get the balance of.
+   * @param {NearSpokeProvider} spokeProvider - The spoke provider.
+   * @returns {Promise<bigint>} The max limit of the token.
+   */
+  static async getLimit(token, spokeProvider) {
+    const rate_limit = await spokeProvider.getRateLimit(token);
+    return BigInt(rate_limit.maxAvailable);
+  }
+  /**
+   * Get available withdrawable amount for the token.
+   * @param {Address} token - The address of the token to get the balance of.
+   * @param {NearSpokeProvider} spokeProvider - The spoke provider.
+   * @returns {Promise<bigint>} The available withdrawable amount of the token.
+   */
+  static async getAvailable(token, spokeProvider) {
+    const rate_limit = await spokeProvider.getRateLimit(token);
+    return BigInt(rate_limit.available);
+  }
+  static async waitForTransaction(spokeProvider, txHash, maxRetries, retryDelay) {
+    try {
+      const accountId = await spokeProvider.walletProvider.getWalletAddress();
+      const receipt = await NearSpokeProvider.waitForTransaction(
+        txHash,
+        accountId,
+        spokeProvider.rpcProvider,
+        maxRetries,
+        retryDelay
+      );
+      if (receipt.status === "success") {
+        return { ok: true, value: true };
+      }
+      return { ok: false, error: new Error(`NEAR transaction failed: ${txHash}`) };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
+    }
+  }
+  static async waitForTransactionRaw(params) {
+    try {
+      const { rpcUrl, txHash, accountId, maxRetries, retryDelay } = params;
+      const receipt = await NearSpokeProvider.waitForTransaction(
+        txHash,
+        accountId,
+        new nearApiJs.JsonRpcProvider({ url: rpcUrl }),
+        maxRetries,
+        retryDelay
+      );
+      if (receipt.status === "success") {
+        return { ok: true, value: true };
+      }
+      return { ok: false, error: new Error(`NEAR transaction failed: ${txHash}`) };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
+    }
+  }
+};
+
+// src/shared/services/spoke/SpokeService.ts
 var SpokeService = class _SpokeService {
   constructor() {
   }
@@ -12362,6 +12696,15 @@ var SpokeService = class _SpokeService {
         raw
       );
     }
+    if (isNearSpokeProviderType(spokeProvider)) {
+      await _SpokeService.verifyDepositSimulation(params, spokeProvider, hubProvider, skipSimulation);
+      return NearSpokeService.deposit(
+        params,
+        spokeProvider,
+        hubProvider,
+        raw
+      );
+    }
     throw new Error("Invalid spoke provider");
   }
   static getSimulateDepositParams(params, spokeProvider, hubProvider) {
@@ -12407,6 +12750,13 @@ var SpokeService = class _SpokeService {
         hubProvider
       );
     }
+    if (isNearSpokeProviderType(spokeProvider)) {
+      return NearSpokeService.getSimulateDepositParams(
+        params,
+        spokeProvider,
+        hubProvider
+      );
+    }
     throw new Error("[getSimulateDepositParams] Invalid spoke provider");
   }
   static async verifyDepositSimulation(params, spokeProvider, hubProvider, skipSimulation) {
@@ -12446,6 +12796,9 @@ var SpokeService = class _SpokeService {
     if (isSonicSpokeProviderType(spokeProvider)) {
       return SonicSpokeService.getDeposit(token, spokeProvider);
     }
+    if (isNearSpokeProviderType(spokeProvider)) {
+      return NearSpokeService.getDeposit(token, spokeProvider);
+    }
     throw new Error("Invalid spoke provider");
   }
   /**
@@ -12519,6 +12872,10 @@ var SpokeService = class _SpokeService {
         raw
       );
     }
+    if (isNearSpokeProviderType(spokeProvider)) {
+      await _SpokeService.verifySimulation(from, payload, spokeProvider, hubProvider, skipSimulation);
+      return await NearSpokeService.callWallet(from, payload, spokeProvider, hubProvider, raw);
+    }
     throw new Error("[callWallet] Invalid spoke provider");
   }
   static async verifySimulation(from, payload, spokeProvider, hubProvider, skipSimulation) {
@@ -12540,6 +12897,30 @@ var SpokeService = class _SpokeService {
       }
     }
   }
+  /**
+   * Get max withdrawable balance for token.
+   * @param {string| Address} token - The address of the token to get the balance of.
+   * @param {SpokeProvider} spokeProvider - The spoke provider.
+   * @returns {Promise<bigint>} The max limit allowed for token.
+   */
+  static getLimit(token, spokeProvider) {
+    if (spokeProvider instanceof NearSpokeProvider) {
+      return NearSpokeService.getLimit(token, spokeProvider);
+    }
+    throw new Error("Invalid spoke provider");
+  }
+  /**
+   * Get available withdrawable amount.
+   * @param {string| Address} token - The address of the token to get the balance of.
+   * @param {SpokeProvider} spokeProvider - The spoke provider.
+   * @returns {Promise<bigint>} The available withdrawable amount for token.
+   */
+  static getAvailable(token, spokeProvider) {
+    if (spokeProvider instanceof NearSpokeProvider) {
+      return NearSpokeService.getAvailable(token, spokeProvider);
+    }
+    throw new Error("Invalid spoke provider");
+  }
   /**
    * Verifies the transaction hash for the spoke chain to exist on chain.
    * Only stellar and solana need to be verified. For other chains, we assume the transaction exists on chain.
@@ -12560,6 +12941,9 @@ var SpokeService = class _SpokeService {
       }
       return result;
     }
+    if (isNearSpokeProvider(spokeProvider)) {
+      return NearSpokeService.waitForTransaction(spokeProvider, txHash);
+    }
     if (isStellarSpokeProvider(spokeProvider)) {
       return StellarSpokeService.waitForTransaction(spokeProvider, txHash);
     }
@@ -12579,12 +12963,14 @@ var SpokeService = class _SpokeService {
         return SolanaSpokeService.waitForConfirmationRaw(params);
       case "STELLAR":
         return StellarSpokeService.waitForTransactionRaw(params);
+      case "NEAR":
+        return NearSpokeService.waitForTransactionRaw(params);
       case "EVM": {
         const result = await EvmSpokeService.waitForTransactionReceipt(params);
         if (!result.ok) {
           return result;
         }
-        if (result.value.status && result.value.status !== "0x1") {
+        if (result.value.status && result.value.status !== "0x1" && result.value.status !== "success") {
           return { ok: false, error: new Error("Transaction reverted") };
         }
         return { ok: true, value: true };
@@ -16354,12 +16740,18 @@ function isSolanaSpokeProviderType(value) {
 function isSolanaSpokeProvider(value) {
   return typeof value === "object" && value !== null && value instanceof SolanaSpokeProvider && !("raw" in value) && value.chainConfig.chain.type === "SOLANA";
 }
+function isNearSpokeProvider(value) {
+  return typeof value === "object" && value !== null && value instanceof NearSpokeProvider && !("raw" in value) && value.chainConfig.chain.type === "NEAR";
+}
 function isStellarSpokeProviderType(value) {
   return typeof value === "object" && value !== null && (isStellarSpokeProvider(value) || isStellarRawSpokeProvider(value));
 }
 function isStellarSpokeProvider(value) {
   return typeof value === "object" && value !== null && value instanceof StellarSpokeProvider && !("raw" in value) && value.chainConfig.chain.type === "STELLAR";
 }
+function isNearSpokeProviderType(value) {
+  return typeof value === "object" && value !== null && (isNearSpokeProvider(value) || isNearRawSpokeProvider(value));
+}
 function isInjectiveSpokeProviderType(value) {
   return typeof value === "object" && value !== null && (isInjectiveSpokeProvider(value) || isInjectiveRawSpokeProvider(value));
 }
@@ -16465,6 +16857,9 @@ function isInjectiveRawSpokeProvider(value) {
 function isSonicRawSpokeProvider(value) {
   return isRawSpokeProvider(value) && value.chainConfig.chain.type === "EVM" && value.chainConfig.chain.id === types.SONIC_MAINNET_CHAIN_ID;
 }
+function isNearRawSpokeProvider(value) {
+  return isRawSpokeProvider(value) && value.chainConfig.chain.type === "NEAR";
+}
 function isAddressString(value) {
   return typeof value === "string";
 }
@@ -16480,6 +16875,9 @@ function isStellarRawSpokeProviderConfig(value) {
 function isSolanaRawSpokeProviderConfig(value) {
   return typeof value === "object" && value !== null && "walletAddress" in value && "chainConfig" in value && "connection" in value && value.chainConfig.chain.type === "SOLANA";
 }
+function isNearRawSpokeProviderConfig(value) {
+  return typeof value === "object" && value !== null && "walletAddress" in value && "chainConfig" in value && value.chainConfig.chain.type === "NEAR";
+}
 async function retry(action, retryCount = DEFAULT_MAX_RETRY, delayMs = DEFAULT_RETRY_DELAY_MS) {
   do {
     try {
@@ -16565,6 +16963,8 @@ function encodeAddress(spokeChainId, address) {
       return viem.toHex(Buffer.from(new web3_js.PublicKey(address).toBytes()));
     case "stellar":
       return `0x${stellarSdk.Address.fromString(address).toScVal().toXDR("hex")}`;
+    case "near":
+      return viem.toHex(Buffer.from(address, "utf-8"));
     default:
       return address;
   }
@@ -16631,6 +17031,10 @@ function constructRawSpokeProvider(config) {
         config.walletAddress
       );
     }
+    case "NEAR": {
+      invariant6__default.default(isNearRawSpokeProviderConfig(config), "Invalid Near raw spoke provider config");
+      return new NearRawSpokeProvider(config.chainConfig, config.walletAddress);
+    }
     default: {
       throw new Error(`Unsupported chain type: ${chainType}`);
     }
@@ -18197,7 +18601,7 @@ var StakingService = class {
       } else {
         hubTxHash = txResult.value;
       }
-      return { ok: true, value: [txResult.value, hubTxHash] };
+      return { ok: true, value: [txResult.value, hubTxHash ?? ""] };
     } catch (error) {
       return {
         ok: false,
@@ -20824,6 +21228,9 @@ exports.MAX_UINT256 = MAX_UINT256;
 exports.MigrationService = MigrationService;
 exports.MoneyMarketDataService = MoneyMarketDataService;
 exports.MoneyMarketService = MoneyMarketService;
+exports.NearBaseSpokeProvider = NearBaseSpokeProvider;
+exports.NearRawSpokeProvider = NearRawSpokeProvider;
+exports.NearSpokeProvider = NearSpokeProvider;
 exports.PartnerFeeClaimService = PartnerFeeClaimService;
 exports.PartnerService = PartnerService;
 exports.ProtocolIntentsAbi = ProtocolIntentsAbi;
@@ -20958,6 +21365,10 @@ exports.isMoneyMarketRepayUnknownError = isMoneyMarketRepayUnknownError;
 exports.isMoneyMarketSubmitTxFailedError = isMoneyMarketSubmitTxFailedError;
 exports.isMoneyMarketSupplyUnknownError = isMoneyMarketSupplyUnknownError;
 exports.isMoneyMarketWithdrawUnknownError = isMoneyMarketWithdrawUnknownError;
+exports.isNearRawSpokeProvider = isNearRawSpokeProvider;
+exports.isNearRawSpokeProviderConfig = isNearRawSpokeProviderConfig;
+exports.isNearSpokeProvider = isNearSpokeProvider;
+exports.isNearSpokeProviderType = isNearSpokeProviderType;
 exports.isNewbnUSDChainId = isNewbnUSDChainId;
 exports.isNewbnUSDToken = isNewbnUSDToken;
 exports.isPartnerFeeAmount = isPartnerFeeAmount;