@wirexapp/wpay-baas-sdk 0.1.10 → 0.1.11

package/README.md

@@ -332,14 +332,18 @@ interface YieldData {
 |--------|-------------|
 | `initializeSmartDepositAddresses(forceRefresh?)` | Create/get all deposit addresses |
 | `getAddresses()` | Get cached addresses |
+| `getDestinationChain()` | Rhino.fi chain code funds are bridged to |
 | `clearAddresses()` | Clear address cache |
 
-**Supported Networks:**
+**Destination chain** follows the SDK `chainId`: `8453` / `84532` → `BASE`, `5042` / `5042002` → `ARC`. Rhino.fi has no testnet chains, so testnet ids resolve to the mainnet code.
+
+Deposit chains with no bridgeable route to the destination (Rhino.fi `DepositAddressNoBridgableTokens`, e.g. USDT-only Kaia and TRON towards Arc) are skipped with a warning; the remaining chains in the group are still created.
+
+**Supported deposit networks:**
 - EVM: Base, Arbitrum, BNB Chain, Ethereum, Kaia, Polygon, Optimism
 - TRON
 - Solana
 - Stellar
-- Solana
 
 ---
 

package/dist/{chunk-GOPZA7GB.js → chunk-YGNDXSTF.js}

@@ -4803,6 +4803,8 @@ var ContractRegistryService = class {
     }
   }
 };
+var STELLAR_CHAIN = "STELLAR";
+var ARC_CHAIN = "ARC";
 var supportedEVMChains = [
   SupportedChains.BASE,
   SupportedChains.ARBITRUM_ONE,
@@ -4812,14 +4814,41 @@ var supportedEVMChains = [
   SupportedChains.POLYGON,
   SupportedChains.OPTIMISM
 ];
-var STELLAR_CHAIN = "STELLAR";
+var RHINO_DESTINATION_CHAIN_BY_CHAIN_ID = {
+  8453: SupportedChains.BASE,
+  84532: SupportedChains.BASE,
+  5042: ARC_CHAIN,
+  5042002: ARC_CHAIN
+};
+function resolveRhinoDestinationChain(chainId) {
+  const destinationChain = RHINO_DESTINATION_CHAIN_BY_CHAIN_ID[chainId];
+  if (!destinationChain) {
+    const supported = Object.keys(RHINO_DESTINATION_CHAIN_BY_CHAIN_ID).join(", ");
+    throw new ConfigurationError(
+      `No Rhino.fi destination chain for chainId ${chainId}. Supported: ${supported}`
+    );
+  }
+  return destinationChain;
+}
 var SYSTEM_SUPPORTED_TOKENS = ["USDT", "USDC", "EURC"];
+var NO_BRIDGEABLE_TOKENS_TAG = "DepositAddressNoBridgableTokens";
+function getUnbridgeableChain(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const { _tag, from } = error;
+  return _tag === NO_BRIDGEABLE_TOKENS_TAG && typeof from === "string" ? from : void 0;
+}
 var SmartDepositAddressesService = class {
   constructor(config) {
     this.rhinoSdkInstance = null;
     this.addresses = [];
     this.walletService = config.walletService;
     this.rhinoApiKey = config.rhinoApiKey;
+    this.destinationChain = resolveRhinoDestinationChain(config.chainId);
+  }
+  getDestinationChain() {
+    return this.destinationChain;
   }
   async initializeSmartDepositAddresses(forceRefresh = false) {
     if (this.addresses.length > 0 && !forceRefresh) {
@@ -4838,7 +4867,7 @@ var SmartDepositAddressesService = class {
         if (!hasTronAddresses) failedGroups.push("TRON");
         if (!hasSolanaAddresses) failedGroups.push("Solana");
         if (!hasStellarAddresses) failedGroups.push("Stellar");
-        console.warn(`Some chain groups failed to initialize: ${failedGroups.join(", ")}`);
+        console.warn(`No deposit addresses for chain groups: ${failedGroups.join(", ")}`);
       }
       this.setAddresses(allAddresses);
       return allAddresses;
@@ -4860,31 +4889,47 @@ var SmartDepositAddressesService = class {
     const smartWalletClient = await this.walletService.getSmartWalletClient();
     const smartWalletAddress = smartWalletClient.account.address;
     const sdk = this.getRhinoSdk();
-    const response = await sdk.api.depositAddresses.create({
-      depositChains: supportedChains,
-      destinationChain: SupportedChains.BASE,
-      destinationAddress: smartWalletAddress,
-      bridgeIfNotSwappable: true,
-      tokenOut: "USDC",
-      postBridgeData: {
-        _tag: "wirexwrap"
-      },
-      reusePolicy: "reuse-existing"
-    });
-    if (response.response.status !== 200 || !response.data) {
-      throw new Error(JSON.stringify(response.error));
-    }
-    const activationPromises = response.data.filter((depositData) => !depositData.isActive).map(async (depositData) => {
-      const activationResponse = await sdk.api.depositAddresses.activate({
-        depositAddress: depositData.depositAddress,
-        depositChain: depositData.depositChain
+    let depositChains = [...supportedChains];
+    while (depositChains.length > 0) {
+      const response = await sdk.api.depositAddresses.create({
+        depositChains,
+        destinationChain: this.destinationChain,
+        destinationAddress: smartWalletAddress,
+        bridgeIfNotSwappable: true,
+        tokenOut: "USDC",
+        postBridgeData: {
+          _tag: "wirexwrap"
+        },
+        reusePolicy: "reuse-existing"
       });
-      if (activationResponse.response.status !== 200) {
-        throw new Error(JSON.stringify(activationResponse.error));
+      if (response.response.status === 200 && response.data) {
+        return this.activateDepositAddresses(sdk, response.data);
+      }
+      const unbridgeableChain = getUnbridgeableChain(response.error);
+      if (!unbridgeableChain || !depositChains.includes(unbridgeableChain)) {
+        throw new Error(JSON.stringify(response.error));
+      }
+      console.warn(
+        `No bridgeable tokens from ${unbridgeableChain} to ${this.destinationChain}, skipping chain`
+      );
+      depositChains = depositChains.filter((chain) => chain !== unbridgeableChain);
+    }
+    return [];
+  }
+  async activateDepositAddresses(sdk, depositAddresses) {
+    const inactiveAddresses = depositAddresses.filter((depositData) => !depositData.isActive);
+    const activationResults = await Promise.allSettled(
+      inactiveAddresses.map((depositData) => this.activateDepositAddress(sdk, depositData))
+    );
+    const failedChains = /* @__PURE__ */ new Set();
+    activationResults.forEach((result, index) => {
+      if (result.status === "rejected") {
+        const chain = inactiveAddresses[index].depositChain;
+        failedChains.add(chain);
+        console.error(`Failed to activate ${chain} deposit address:`, result.reason);
       }
     });
-    await Promise.all(activationPromises);
-    return response.data.map((item) => {
+    return depositAddresses.filter((item) => !failedChains.has(item.depositChain)).map((item) => {
       const supportedTokens = (item.supportedTokens || []).map((token) => token.symbol).filter((symbol) => SYSTEM_SUPPORTED_TOKENS.includes(symbol));
       return {
         depositChain: item.depositChain,
@@ -4896,6 +4941,15 @@ var SmartDepositAddressesService = class {
       };
     });
   }
+  async activateDepositAddress(sdk, depositData) {
+    const activationResponse = await sdk.api.depositAddresses.activate({
+      depositAddress: depositData.depositAddress,
+      depositChain: depositData.depositChain
+    });
+    if (activationResponse.response.status !== 200) {
+      throw new Error(JSON.stringify(activationResponse.error));
+    }
+  }
   async createSmartDepositAddresses() {
     const results = await Promise.allSettled([
       this.createSmartDepositAddressForChains(supportedEVMChains),
@@ -5132,7 +5186,8 @@ var CryptoModule = class {
     if (config.rhinoApiKey) {
       this._smartDepositService = new SmartDepositAddressesService({
         walletService: this._walletService,
-        rhinoApiKey: config.rhinoApiKey
+        rhinoApiKey: config.rhinoApiKey,
+        chainId: config.chainId
       });
     }
   }
@@ -5143,5 +5198,5 @@ var CryptoModule = class {
 };
 
 export { BaseAccountAbstractionService, BaseAccountContractService, BaseCryptoService, BaseOnboardingService, BaseWalletService, BaseYieldService, ContractRegistryService, CryptoModule, chainRegistry };
-//# sourceMappingURL=chunk-GOPZA7GB.js.map
-//# sourceMappingURL=chunk-GOPZA7GB.js.map
+//# sourceMappingURL=chunk-YGNDXSTF.js.map
+//# sourceMappingURL=chunk-YGNDXSTF.js.map