@weblock-wallet/sdk 0.1.74 → 0.1.76

package/dist/index.js

@@ -106908,12 +106908,128 @@ var UserModule = class {
   }
 };
 
+// src/core/config/weblockFujiDeployment.ts
+var WEBLOCK_FUJI_DEPLOYMENT = {
+  chainId: 43113,
+  network: "fuji",
+  rpcUrl: "https://api.avax-test.network/ext/bc/C/rpc",
+  explorerBaseUrl: "https://testnet.snowtrace.io",
+  treasury: "0x67394081091BDE902b38774076a332240Aa14b27",
+  tokens: {
+    USDR: {
+      address: "0xbc3A31c1788624E5bFf69cdC3a1E7405A01C6De2",
+      decimals: 18,
+      symbol: "USDR"
+    },
+    USDT: {
+      address: "0x4CcEF90D730AB83366a3936FA301536649E105Ed",
+      decimals: 6,
+      symbol: "USDT"
+    },
+    WFT: {
+      address: "0x64529efA2bF566794d051f7531B53EE9413E7794",
+      decimals: 18,
+      symbol: "WFT"
+    }
+  },
+  contracts: {
+    rbtFactory: "0x6bF159f474094915805c9768c533c6c24737F8a3",
+    investRouter: "0x41c1EeD232D29FCc19c09b0e26A70e4B8c9b34e6",
+    product1: {
+      offeringId: 1n,
+      seriesId: 1n,
+      rbtAsset: "0x6173a35cBB99B82c51c6A0e0265C06B7955Eb017",
+      unitPriceWei: 1000000000000000000n,
+      // 1 USDR
+      paymentToken: "0xbc3A31c1788624E5bFf69cdC3a1E7405A01C6De2"
+      // USDR
+    }
+  }
+};
+
 // src/modules/wallet.ts
+var FUJI_CHAIN_ID = WEBLOCK_FUJI_DEPLOYMENT.chainId;
+var FUJI_USDR_ADDRESS = WEBLOCK_FUJI_DEPLOYMENT.tokens.USDR.address.toLowerCase();
+var FUJI_RBT_ADDRESS = WEBLOCK_FUJI_DEPLOYMENT.contracts.product1.rbtAsset.toLowerCase();
+var FUJI_RBT_SERIES_ID = Number(
+  WEBLOCK_FUJI_DEPLOYMENT.contracts.product1.seriesId
+);
 var WalletModule = class {
   constructor(options, core) {
     this.options = options;
     this.core = core;
   }
+  pickDefaultNetwork(availableNetworks) {
+    if (!availableNetworks.length) return null;
+    const fuji = availableNetworks.find(
+      (network) => network.chainId === FUJI_CHAIN_ID && (network.isTestnet || (network.name || "").toLowerCase().includes("fuji") || (network.rpcUrl || "").toLowerCase().includes("avax-test"))
+    ) ?? null;
+    if (fuji) return fuji;
+    return availableNetworks.find((network) => !network.isTestnet) ?? availableNetworks[0];
+  }
+  withDefaultRegisteredCoins(network, registered) {
+    if (!network) return registered;
+    const map = /* @__PURE__ */ new Map();
+    for (const coin of registered) {
+      if (!coin?.contractAddress) continue;
+      map.set(coin.contractAddress.toLowerCase(), {
+        ...coin,
+        contractAddress: coin.contractAddress.toLowerCase()
+      });
+    }
+    if (network.chainId === FUJI_CHAIN_ID && !map.has(FUJI_USDR_ADDRESS)) {
+      map.set(FUJI_USDR_ADDRESS, {
+        id: "default-fuji-usdr",
+        blockchainId: network.id,
+        name: "WeBlock USD Settlement Token",
+        symbol: "USDR",
+        contractAddress: FUJI_USDR_ADDRESS,
+        decimals: 18
+      });
+    }
+    return Array.from(map.values());
+  }
+  decodeHexBalanceToDecimal(value) {
+    if (!value) return "0";
+    try {
+      return BigInt(value).toString();
+    } catch {
+      return "0";
+    }
+  }
+  async getFujiRbtTokenInfo(networkId, walletAddress) {
+    try {
+      const rawHex = await this.core.asset.getERC1155Balance({
+        networkId,
+        tokenAddress: FUJI_RBT_ADDRESS,
+        walletAddress,
+        tokenId: FUJI_RBT_SERIES_ID
+      });
+      const raw = this.decodeHexBalanceToDecimal(rawHex);
+      const balance = {
+        raw,
+        formatted: TokenAmount.fromWei(raw, 0),
+        decimals: 0,
+        symbol: "RBT"
+      };
+      return {
+        address: FUJI_RBT_ADDRESS,
+        name: "RBT Property Token",
+        symbol: "RBT",
+        decimals: 0,
+        balance,
+        totalSupply: {
+          raw: "0",
+          formatted: "0",
+          decimals: 0,
+          symbol: "RBT"
+        }
+      };
+    } catch (error) {
+      console.warn("Failed to load default RBT balance:", error);
+      return null;
+    }
+  }
   async getInfo() {
     try {
       console.log("1. \uB85C\uADF8\uC778 \uC0C1\uD0DC \uD655\uC778 \uC2DC\uC791");
@@ -106939,7 +107055,13 @@ var WalletModule = class {
       console.log("\uD604\uC7AC \uB124\uD2B8\uC6CC\uD06C:", currentNetwork);
       console.log("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uB124\uD2B8\uC6CC\uD06C:", availableNetworks);
       if (!currentNetwork) {
-        const defaultNetwork = availableNetworks.find((n5) => !n5.isTestnet) || availableNetworks[0];
+        const defaultNetwork = this.pickDefaultNetwork(availableNetworks);
+        if (!defaultNetwork) {
+          throw new SDKError(
+            "\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uB124\uD2B8\uC6CC\uD06C\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4",
+            "NETWORK_ERROR" /* NETWORK_ERROR */
+          );
+        }
         await this.core.network.switchNetwork(defaultNetwork.id);
         console.log("\uAE30\uBCF8 \uB124\uD2B8\uC6CC\uD06C\uB85C \uC124\uC815:", defaultNetwork.name);
       }
@@ -106965,12 +107087,14 @@ var WalletModule = class {
       let tokens = [];
       try {
         const registered = await this.core.asset.getRegisteredCoins(network.id);
-        if (registered?.length) {
-          const unique = new Map(
-            registered.map((c5) => [c5.contractAddress.toLowerCase(), c5])
-          );
-          tokens = await Promise.all(
-            Array.from(unique.values()).map(async (coin) => {
+        const targetCoins = this.withDefaultRegisteredCoins(
+          network,
+          registered ?? []
+        );
+        const tokenMap = /* @__PURE__ */ new Map();
+        if (targetCoins.length) {
+          const results = await Promise.allSettled(
+            targetCoins.map(async (coin) => {
               const full = await this.core.asset.getTokenFullInfo({
                 networkId: network.id,
                 tokenAddress: coin.contractAddress,
@@ -106985,7 +107109,24 @@ var WalletModule = class {
               };
             })
           );
+          results.forEach((result) => {
+            if (result.status === "fulfilled") {
+              tokenMap.set(
+                result.value.address.toLowerCase(),
+                result.value
+              );
+              return;
+            }
+            console.warn("Registered token load failed:", result.reason);
+          });
+        }
+        if (network.chainId === FUJI_CHAIN_ID) {
+          const rbtToken = await this.getFujiRbtTokenInfo(network.id, address);
+          if (rbtToken) {
+            tokenMap.set(rbtToken.address.toLowerCase(), rbtToken);
+          }
         }
+        tokens = Array.from(tokenMap.values());
       } catch (e7) {
         console.warn("Registered token load failed:", e7);
         tokens = [];