@wirexapp/wpay-baas-sdk 0.1.10 → 0.1.12

package/README.md

@@ -332,14 +332,20 @@ 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:**
-- EVM: Base, Arbitrum, BNB Chain, Ethereum, Kaia, Polygon, Optimism
+**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.
+
+The destination chain is itself requested as a deposit chain, so the EVM group also holds a same-chain address — `ARC` → `ARC` when the SDK runs on Arc, `BASE` → `BASE` on Base.
+
+Deposit chains the destination rejects are skipped with a warning and the remaining chains in the group are still created: no bridgeable route (Rhino.fi `DepositAddressNoBridgableTokens`, e.g. USDT-only Kaia and TRON towards Arc) and chains Rhino.fi has not enabled for deposit addresses (`DepositAddressChainsNotSupported`).
+
+**Supported deposit networks:**
+- EVM: the destination chain (Base or Arc), Base, Arbitrum, BNB Chain, Ethereum, Kaia, Polygon, Optimism
 - TRON
 - Solana
 - Stellar
-- Solana
 
 ---
 

package/dist/{chunk-GOPZA7GB.js → chunk-IAY3T66T.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,51 @@ var supportedEVMChains = [
   SupportedChains.POLYGON,
   SupportedChains.OPTIMISM
 ];
-var STELLAR_CHAIN = "STELLAR";
+function getEvmDepositChains(destinationChain) {
+  return supportedEVMChains.includes(destinationChain) ? [...supportedEVMChains] : [destinationChain, ...supportedEVMChains];
+}
+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";
+var CHAINS_NOT_SUPPORTED_TAG = "DepositAddressChainsNotSupported";
+function getRejectedChains(error) {
+  if (!error || typeof error !== "object") {
+    return [];
+  }
+  const { _tag, from, chains } = error;
+  if (_tag === NO_BRIDGEABLE_TOKENS_TAG) {
+    return typeof from === "string" ? [from] : [];
+  }
+  if (_tag === CHAINS_NOT_SUPPORTED_TAG && Array.isArray(chains)) {
+    return chains.filter((chain) => typeof chain === "string");
+  }
+  return [];
+}
 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 +4877,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 +4899,49 @@ 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 rejectedChains = getRejectedChains(response.error).filter(
+        (chain) => depositChains.includes(chain)
+      );
+      if (rejectedChains.length === 0) {
+        throw new Error(JSON.stringify(response.error));
+      }
+      console.warn(
+        `Rhino.fi rejected deposit chains ${rejectedChains.join(", ")} for destination ${this.destinationChain}, skipping them`
+      );
+      depositChains = depositChains.filter((chain) => !rejectedChains.includes(chain));
+    }
+    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,9 +4953,18 @@ 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),
+      this.createSmartDepositAddressForChains(getEvmDepositChains(this.destinationChain)),
       this.createSmartDepositAddressForChains([SupportedChains.TRON]),
       this.createSmartDepositAddressForChains([SupportedChains.SOLANA]),
       this.createSmartDepositAddressForChains([STELLAR_CHAIN])
@@ -4956,7 +5022,7 @@ var SmartDepositAddressesService = class {
   getChainsForGroup(chainGroup) {
     switch (chainGroup) {
       case "evm":
-        return supportedEVMChains;
+        return getEvmDepositChains(this.destinationChain);
       case "tron":
         return [SupportedChains.TRON];
       case "solana":
@@ -4968,7 +5034,7 @@ var SmartDepositAddressesService = class {
     }
   }
   getChainGroupByChainCode(chainCode) {
-    if (supportedEVMChains.includes(chainCode)) {
+    if (getEvmDepositChains(this.destinationChain).includes(chainCode)) {
       return "evm";
     }
     if (chainCode === SupportedChains.TRON) {
@@ -5132,7 +5198,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 +5210,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-IAY3T66T.js.map
+//# sourceMappingURL=chunk-IAY3T66T.js.map