@weblock-wallet/sdk 0.1.50 → 0.1.52

package/dist/index.js

@@ -104971,21 +104971,19 @@ var UserClient = class {
    * - { coin: CoinResponse }
    * - { data: CoinResponse }
    */
-  // UserClient 클래스 내부의 registerToken()을 아래로 교체
   async registerToken(req) {
-    const blockchainId = req.blockchainId ?? req.networkId;
-    const contractAddress = String(
-      req.contractAddress ?? req.tokenAddress ?? req.address ?? ""
-    ).trim().toLowerCase();
+    const blockchainId = req.blockchainId;
+    const contractAddress = this.normalizeAddress(req.contractAddress);
     const name2 = req.name;
     const symbol = req.symbol;
     const decimals = req.decimals;
     const candidates = [
-      // 1) 주소만 받는 케이스
+      // 1) 최신 스펙으로 바뀌며 "주소만" 받는 경우
       { blockchainId, contractAddress },
+      // 2) 필드명이 tokenAddress / address로 바뀐 경우
       { blockchainId, tokenAddress: contractAddress },
       { blockchainId, address: contractAddress },
-      // 2) 메타까지 받는 케이스
+      // 3) 구 스펙(메타 포함) 유지/필요한 경우
       ...name2 && symbol && typeof decimals === "number" ? [
         { blockchainId, contractAddress, name: name2, symbol, decimals },
         {
@@ -104997,29 +104995,45 @@ var UserClient = class {
         },
         { blockchainId, address: contractAddress, name: name2, symbol, decimals }
       ] : [],
-      // 3) 파라미터명이 networkId로 바뀐 케이스
-      { networkId: blockchainId, contractAddress },
-      ...name2 && symbol && typeof decimals === "number" ? [{ networkId: blockchainId, contractAddress, name: name2, symbol, decimals }] : []
+      // 4) blockchainId가 networkId로 바뀐 경우
+      ...name2 && symbol && typeof decimals === "number" ? [
+        {
+          networkId: blockchainId,
+          contractAddress,
+          name: name2,
+          symbol,
+          decimals
+        },
+        {
+          networkId: blockchainId,
+          tokenAddress: contractAddress,
+          name: name2,
+          symbol,
+          decimals
+        }
+      ] : [{ networkId: blockchainId, contractAddress }]
     ];
     let lastError = null;
     for (const body of candidates) {
       try {
-        const res = await this.postAuthed(
-          "/v1/users/register-token",
+        const res = await this.client.post(
+          `${this.baseUrl}/register-token`,
           body
         );
-        const coin = res?.coin ?? res?.data ?? res;
-        if (coin?.contractAddress) {
-          return {
-            ...coin,
-            contractAddress: String(coin.contractAddress).trim().toLowerCase(),
-            decimals: typeof coin.decimals === "number" ? coin.decimals : Number(coin.decimals)
-          };
+        const coin = this.unwrapCoin(res);
+        if (!coin?.contractAddress) {
+          continue;
         }
+        return {
+          ...coin,
+          contractAddress: this.normalizeAddress(coin.contractAddress),
+          decimals: Number(coin.decimals)
+        };
       } catch (e7) {
         lastError = e7;
-        const status = e7?.status ?? e7?.response?.status ?? e7?.cause?.status ?? e7?.cause?.response?.status;
-        if (status === 400 || status === 409 || status === 422) continue;
+        const status = this.extractStatus(e7);
+        if (status === 400 || status === 422) continue;
+        if (status === 409) continue;
         throw e7;
       }
     }
@@ -105043,32 +105057,6 @@ var UserClient = class {
       { needsAccessToken: true }
     );
   }
-  // UserClient 클래스 내부에 추가
-  async postAuthed(path, body) {
-    const httpAny = this.client;
-    const headers = (typeof httpAny.getAuthHeaders === "function" ? await httpAny.getAuthHeaders() : typeof httpAny.getHeaders === "function" ? await httpAny.getHeaders() : void 0) ?? void 0;
-    const attempts = [];
-    if (typeof httpAny.post === "function") {
-      attempts.push(() => httpAny.post(path, body, headers));
-      attempts.push(() => httpAny.post(path, body, { headers }));
-      attempts.push(() => httpAny.post(path, body));
-    }
-    if (typeof httpAny.request === "function") {
-      attempts.push(
-        () => httpAny.request({ method: "POST", path, body, headers })
-      );
-      attempts.push(() => httpAny.request("POST", path, body, headers));
-    }
-    let lastError = null;
-    for (const fn of attempts) {
-      try {
-        return await fn();
-      } catch (e7) {
-        lastError = e7;
-      }
-    }
-    throw lastError ?? new Error(`POST ${path} failed`);
-  }
 };
 
 // src/clients/api/wallets.ts
@@ -106195,17 +106183,14 @@ var AssetService = class extends EventEmitter {
         params.spender,
         params.amount
       ]);
-      const response = await this.rpcClient.sendRpc({
-        chainId,
-        method: "eth_sendRawTransaction" /* ETH_SEND_RAW_TRANSACTION */,
-        params: [
-          {
-            to: params.tokenAddress,
-            data
-          }
-        ]
+      const txHash = await this.walletService.sendTransaction({
+        to: params.tokenAddress,
+        value: "0",
+        data,
+        chainId
       });
-      return response.result;
+      this.trackTransaction(txHash, chainId);
+      return txHash;
     } catch (error) {
       throw new SDKError(
         "Failed to approve token",
@@ -106288,6 +106273,402 @@ var AssetService = class extends EventEmitter {
   // }
 };
 
+// src/core/services/investment.ts
+import { Interface as Interface3 } from "ethers";
+
+// src/contract/weblock.ts
+var RBT_PRIMARY_SALE_ROUTER_ABI = [
+  {
+    inputs: [{ name: "offeringId", type: "uint256" }],
+    name: "offerings",
+    outputs: [
+      { name: "asset", type: "address" },
+      { name: "seriesId", type: "uint256" },
+      { name: "unitPrice", type: "uint256" },
+      { name: "remainingUnits", type: "uint256" },
+      { name: "startAt", type: "uint64" },
+      { name: "endAt", type: "uint64" },
+      { name: "treasury", type: "address" },
+      { name: "enabled", type: "bool" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "offeringId", type: "uint256" },
+      { name: "units", type: "uint256" },
+      { name: "maxCost", type: "uint256" }
+    ],
+    name: "buy",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var RBT_PROPERTY_TOKEN_ABI = [
+  {
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "id", type: "uint256" }
+    ],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    name: "claim",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "account", type: "address" }
+    ],
+    name: "claimable",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/core/services/investment.ts
+var MAX_UINT256 = 2n ** 256n - 1n;
+var InvestmentService = class extends EventEmitter {
+  constructor(rpcClient, walletService, networkService) {
+    super();
+    this.rpcClient = rpcClient;
+    this.walletService = walletService;
+    this.networkService = networkService;
+    this.chainIdCache = /* @__PURE__ */ new Map();
+    this.erc20Interface = new Interface3(ERC20_ABI2);
+    this.saleInterface = new Interface3(RBT_PRIMARY_SALE_ROUTER_ABI);
+    this.rbtInterface = new Interface3(RBT_PROPERTY_TOKEN_ABI);
+  }
+  assertHexAddress(addr, field) {
+    const a5 = (addr ?? "").trim();
+    if (!a5.startsWith("0x") || a5.length !== 42) {
+      throw new SDKError(`Invalid ${field}`, "INVALID_PARAMS" /* INVALID_PARAMS */);
+    }
+  }
+  toBigInt(v5, field) {
+    try {
+      if (typeof v5 === "bigint") return v5;
+      if (typeof v5 === "number") {
+        if (!Number.isFinite(v5) || v5 < 0) throw new Error("invalid number");
+        return BigInt(v5);
+      }
+      const s5 = (v5 ?? "").toString().trim();
+      if (!s5) throw new Error("empty");
+      return BigInt(s5);
+    } catch {
+      throw new SDKError(`Invalid ${field}`, "INVALID_PARAMS" /* INVALID_PARAMS */);
+    }
+  }
+  /**
+   * Resolve `networkId` (wallet backend blockchainId UUID) or chainId string -> EVM chainId
+   */
+  async resolveChainId(networkId) {
+    const trimmed = (networkId ?? "").trim();
+    const cached = this.chainIdCache.get(trimmed);
+    if (cached) return cached;
+    const numeric = Number(trimmed);
+    if (!Number.isNaN(numeric) && Number.isFinite(numeric) && numeric > 0) {
+      this.chainIdCache.set(trimmed, numeric);
+      return numeric;
+    }
+    try {
+      const current = await this.networkService.getCurrentNetwork();
+      if (current && current.id === trimmed) {
+        this.chainIdCache.set(trimmed, current.chainId);
+        return current.chainId;
+      }
+      if (current && String(current.chainId) === trimmed) {
+        this.chainIdCache.set(trimmed, current.chainId);
+        return current.chainId;
+      }
+    } catch {
+    }
+    const networks = await this.networkService.getRegisteredNetworks();
+    const found = networks.find((n5) => n5.id === trimmed);
+    if (found) {
+      this.chainIdCache.set(trimmed, found.chainId);
+      return found.chainId;
+    }
+    const foundByChainId = networks.find((n5) => String(n5.chainId) === trimmed);
+    if (foundByChainId) {
+      this.chainIdCache.set(trimmed, foundByChainId.chainId);
+      return foundByChainId.chainId;
+    }
+    throw new SDKError("Invalid network", "INVALID_NETWORK" /* INVALID_NETWORK */);
+  }
+  async ethCall(chainId, to, data) {
+    const res = await this.rpcClient.sendRpc({
+      chainId,
+      method: "eth_call" /* ETH_CALL */,
+      params: [{ to, data }, "latest"]
+    });
+    if (res.error) {
+      throw new SDKError(
+        `ETH_CALL failed: ${res.error.message}`,
+        "REQUEST_FAILED" /* REQUEST_FAILED */,
+        res.error
+      );
+    }
+    if (res.result === void 0) {
+      throw new SDKError(
+        "ETH_CALL returned empty result",
+        "REQUEST_FAILED" /* REQUEST_FAILED */
+      );
+    }
+    return res.result;
+  }
+  decodeU256(resultHex, method) {
+    const decoded = this.erc20Interface.decodeFunctionResult(
+      method,
+      resultHex
+    );
+    return BigInt(decoded[0].toString());
+  }
+  async getOffering(params) {
+    this.assertHexAddress(params.saleRouterAddress, "saleRouterAddress");
+    const chainId = await this.resolveChainId(params.networkId);
+    const offeringId = this.toBigInt(params.offeringId, "offeringId");
+    const data = this.saleInterface.encodeFunctionData("offerings", [
+      offeringId
+    ]);
+    const result = await this.ethCall(chainId, params.saleRouterAddress, data);
+    const decoded = this.saleInterface.decodeFunctionResult("offerings", result);
+    const asset = decoded[0];
+    const seriesId = BigInt(decoded[1].toString());
+    const unitPrice = BigInt(decoded[2].toString());
+    const remainingUnits = BigInt(decoded[3].toString());
+    const startAt = BigInt(decoded[4].toString());
+    const endAt = BigInt(decoded[5].toString());
+    const treasury = decoded[6];
+    const enabled = Boolean(decoded[7]);
+    return {
+      asset,
+      seriesId,
+      unitPrice,
+      remainingUnits,
+      startAt,
+      endAt,
+      treasury,
+      enabled
+    };
+  }
+  /**
+   * USDR로 투자 (approve 필요. autoApprove 옵션 제공)
+   * - Router.buy(offeringId, units, maxCost) 호출
+   */
+  async investRbtWithUsdr(params) {
+    this.assertHexAddress(params.usdrAddress, "usdrAddress");
+    this.assertHexAddress(params.saleRouterAddress, "saleRouterAddress");
+    const chainId = await this.resolveChainId(params.networkId);
+    const offeringId = this.toBigInt(params.offeringId, "offeringId");
+    const units = this.toBigInt(params.units, "units");
+    if (units <= 0n) {
+      throw new SDKError("Invalid units", "INVALID_PARAMS" /* INVALID_PARAMS */);
+    }
+    const offering = await this.getOffering({
+      networkId: params.networkId,
+      saleRouterAddress: params.saleRouterAddress,
+      offeringId
+    });
+    if (!offering.enabled) {
+      throw new SDKError("Offering is disabled", "REQUEST_FAILED" /* REQUEST_FAILED */);
+    }
+    const cost = units * offering.unitPrice;
+    const maxCost = params.maxCostWei != null ? this.toBigInt(params.maxCostWei, "maxCostWei") : cost;
+    if (maxCost < cost) {
+      throw new SDKError(
+        "maxCostWei is less than required cost",
+        "INVALID_PARAMS" /* INVALID_PARAMS */
+      );
+    }
+    const buyer = await this.walletService.getAddress();
+    let approvalTxHash;
+    const autoApprove = params.autoApprove ?? true;
+    const approveMax = params.approveMax ?? true;
+    const waitForApprovalReceipt = params.waitForApprovalReceipt ?? true;
+    if (autoApprove) {
+      const allowanceData = this.erc20Interface.encodeFunctionData(
+        "allowance",
+        [buyer, params.saleRouterAddress]
+      );
+      const allowanceHex = await this.ethCall(
+        chainId,
+        params.usdrAddress,
+        allowanceData
+      );
+      const allowanceDecoded = this.erc20Interface.decodeFunctionResult(
+        "allowance",
+        allowanceHex
+      );
+      const allowance = BigInt(allowanceDecoded[0].toString());
+      if (allowance < cost) {
+        const approveAmount = approveMax ? MAX_UINT256 : cost;
+        const approveData = this.erc20Interface.encodeFunctionData("approve", [
+          params.saleRouterAddress,
+          approveAmount.toString()
+        ]);
+        approvalTxHash = await this.walletService.sendTransaction({
+          to: params.usdrAddress,
+          value: "0",
+          data: approveData,
+          chainId,
+          gasLimit: params.gasLimitApprove
+        });
+        this.trackTransaction(approvalTxHash, chainId);
+        if (waitForApprovalReceipt) {
+          const ok = await this.waitForSuccessReceipt(approvalTxHash, chainId);
+          if (!ok) {
+            throw new SDKError(
+              "Approve transaction failed",
+              "TRANSACTION_FAILED" /* TRANSACTION_FAILED */
+            );
+          }
+        }
+      }
+    }
+    const buyData = this.saleInterface.encodeFunctionData("buy", [
+      offeringId,
+      units,
+      maxCost
+    ]);
+    const purchaseTxHash = await this.walletService.sendTransaction({
+      to: params.saleRouterAddress,
+      value: "0",
+      data: buyData,
+      chainId,
+      gasLimit: params.gasLimitBuy
+    });
+    this.trackTransaction(purchaseTxHash, chainId);
+    return {
+      offering,
+      costWei: cost.toString(),
+      approvalTxHash,
+      purchaseTxHash
+    };
+  }
+  /**
+   * RBT 수익(이자) claim
+   * - RBTPropertyToken.claim(seriesId)
+   */
+  async claimRbtRevenue(params) {
+    this.assertHexAddress(params.rbtAssetAddress, "rbtAssetAddress");
+    const chainId = await this.resolveChainId(params.networkId);
+    const seriesId = this.toBigInt(params.seriesId, "seriesId");
+    const claimData = this.rbtInterface.encodeFunctionData("claim", [seriesId]);
+    const txHash = await this.walletService.sendTransaction({
+      to: params.rbtAssetAddress,
+      value: "0",
+      data: claimData,
+      chainId,
+      gasLimit: params.gasLimit
+    });
+    this.trackTransaction(txHash, chainId);
+    return { txHash };
+  }
+  /**
+   * claimable 조회 (eth_call)
+   */
+  async getClaimable(params) {
+    this.assertHexAddress(params.rbtAssetAddress, "rbtAssetAddress");
+    const chainId = await this.resolveChainId(params.networkId);
+    const seriesId = this.toBigInt(params.seriesId, "seriesId");
+    const account = params.account ?? await this.walletService.getAddress();
+    this.assertHexAddress(account, "account");
+    const data = this.rbtInterface.encodeFunctionData("claimable", [
+      seriesId,
+      account
+    ]);
+    const result = await this.ethCall(chainId, params.rbtAssetAddress, data);
+    const decoded = this.rbtInterface.decodeFunctionResult("claimable", result);
+    return BigInt(decoded[0].toString()).toString();
+  }
+  /**
+   * RBT balanceOf 조회 (eth_call)
+   */
+  async getRbtBalance(params) {
+    this.assertHexAddress(params.rbtAssetAddress, "rbtAssetAddress");
+    const chainId = await this.resolveChainId(params.networkId);
+    const seriesId = this.toBigInt(params.seriesId, "seriesId");
+    const account = params.account ?? await this.walletService.getAddress();
+    this.assertHexAddress(account, "account");
+    const data = this.rbtInterface.encodeFunctionData("balanceOf", [
+      account,
+      seriesId
+    ]);
+    const result = await this.ethCall(chainId, params.rbtAssetAddress, data);
+    const decoded = this.rbtInterface.decodeFunctionResult("balanceOf", result);
+    return BigInt(decoded[0].toString()).toString();
+  }
+  async waitForSuccessReceipt(txHash, chainId) {
+    let retryCount = 0;
+    const MAX_RETRIES = 20;
+    while (retryCount < MAX_RETRIES) {
+      const res = await this.rpcClient.sendRpc({
+        chainId,
+        method: "eth_getTransactionReceipt" /* ETH_GET_TRANSACTION_RECEIPT */,
+        params: [txHash]
+      });
+      if (res.result) {
+        return res.result.status === "0x1";
+      }
+      retryCount++;
+      await new Promise((r5) => setTimeout$1(r5, 3e3));
+    }
+    return false;
+  }
+  trackTransaction(txHash, chainId) {
+    let retryCount = 0;
+    const MAX_RETRIES = 20;
+    const checkStatus = async () => {
+      try {
+        const response = await this.rpcClient.sendRpc({
+          chainId,
+          method: "eth_getTransactionReceipt" /* ETH_GET_TRANSACTION_RECEIPT */,
+          params: [txHash]
+        });
+        if (response.result) {
+          const status = response.result.status === "0x1" ? "SUCCESS" /* SUCCESS */ : "FAILED" /* FAILED */;
+          this.emit("transactionStatusChanged", {
+            hash: txHash,
+            status,
+            timestamp: Date.now()
+          });
+          return;
+        }
+        retryCount++;
+        if (retryCount < MAX_RETRIES) {
+          setTimeout$1(checkStatus, 3e3);
+        } else {
+          this.emit("transactionStatusChanged", {
+            hash: txHash,
+            status: "FAILED" /* FAILED */,
+            timestamp: Date.now(),
+            error: "Transaction timeout"
+          });
+        }
+      } catch (error) {
+        this.emit("transactionStatusChanged", {
+          hash: txHash,
+          status: "FAILED" /* FAILED */,
+          timestamp: Date.now(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    };
+    checkStatus();
+  }
+};
+
 // src/core/internal.ts
 var InternalCoreImpl = class {
   constructor(options) {
@@ -106329,16 +106710,7 @@ var InternalCoreImpl = class {
       getTokenBalance: (params) => this.assetService.getTokenBalance(params),
       approveToken: (params) => this.assetService.approveToken(params),
       getAllowance: (params) => this.assetService.getAllowance(params),
-      // getTokenInfo: (params: TokenInfoParams) =>
-      //   this.assetService.getTokenInfo(params),
       addNFTCollection: (params) => this.assetService.addNFTCollection(params),
-      // checkSecurityTokenCompliance: (params: {
-      //   networkId: string
-      //   tokenAddress: string
-      //   from: string
-      //   to: string
-      //   amount: string
-      // }) => this.assetService.checkSecurityTokenCompliance(params),
       on: (event, listener) => this.assetService.on(event, listener),
       off: (event, listener) => this.assetService.off(event, listener),
       getTokenInfo: (params) => this.assetService.getTokenInfo(params),
@@ -106346,6 +106718,15 @@ var InternalCoreImpl = class {
       getTokenFullInfo: (params) => this.assetService.getTokenFullInfo(params),
       getRegisteredCoins: (networkId) => this.assetService.getRegisteredCoins(networkId)
     };
+    this.investment = {
+      getOffering: (params) => this.investmentService.getOffering(params),
+      investRbtWithUsdr: (params) => this.investmentService.investRbtWithUsdr(params),
+      claimRbtRevenue: (params) => this.investmentService.claimRbtRevenue(params),
+      getClaimable: (params) => this.investmentService.getClaimable(params),
+      getRbtBalance: (params) => this.investmentService.getRbtBalance(params),
+      on: (event, listener) => this.investmentService.on(event, listener),
+      off: (event, listener) => this.investmentService.off(event, listener)
+    };
     const httpClient = new HttpClient(options);
     const firebase = new FirebaseAuth(options);
     const userClient = new UserClient(httpClient);
@@ -106371,6 +106752,11 @@ var InternalCoreImpl = class {
       userClient,
       options.orgHost
     );
+    this.investmentService = new InvestmentService(
+      rpcClient,
+      this.walletService,
+      this.networkService
+    );
   }
 };
 
@@ -106646,6 +107032,35 @@ var AssetModule = class {
   }
 };
 
+// src/modules/Investment.ts
+var InvestmentModule = class {
+  constructor(options, core) {
+    this.options = options;
+    this.core = core;
+  }
+  getOffering(params) {
+    return this.core.investment.getOffering(params);
+  }
+  investRbtWithUsdr(params) {
+    return this.core.investment.investRbtWithUsdr(params);
+  }
+  claimRbtRevenue(params) {
+    return this.core.investment.claimRbtRevenue(params);
+  }
+  getClaimable(params) {
+    return this.core.investment.getClaimable(params);
+  }
+  getRbtBalance(params) {
+    return this.core.investment.getRbtBalance(params);
+  }
+  on(event, listener) {
+    this.core.investment.on(event, listener);
+  }
+  off(event, listener) {
+    this.core.investment.off(event, listener);
+  }
+};
+
 // src/utils/network.ts
 var KNOWN_NETWORKS = {
   1: {
@@ -106713,92 +107128,178 @@ var WeBlockSDK = class {
     this.initialized = false;
     this.user = {
       signIn: async (provider) => {
+        this.ensureInitialized();
         return this.userModule.signIn(provider);
       },
       createWallet: async (password) => {
+        this.ensureInitialized();
         return this.userModule.createWallet(password);
       },
       retrieveWallet: async (password) => {
+        this.ensureInitialized();
         return this.userModule.retrieveWallet(password);
       },
       /**
        * ✅ 추가: PIN reset API 노출
        */
       resetPin: async (newPassword) => {
+        this.ensureInitialized();
         return this.userModule.resetPin(newPassword);
       },
       signOut: async () => {
+        this.ensureInitialized();
         return this.userModule.signOut();
       }
     };
     this.wallet = {
       getInfo: async () => {
+        this.ensureInitialized();
         return this.walletModule.getInfo();
       },
       onWalletUpdate: (callback) => {
+        this.ensureInitialized();
         return this.walletModule.onWalletUpdate(callback);
       },
       onTransactionUpdate: (callback) => {
+        this.ensureInitialized();
         return this.walletModule.onTransactionUpdate(callback);
       },
       getBalance: (address, chainId) => {
+        this.ensureInitialized();
         return this.walletModule.getBalance(address, chainId);
       },
       getTransactionCount: (address, chainId) => {
+        this.ensureInitialized();
         return this.walletModule.getTransactionCount(address, chainId);
       },
       getBlockNumber: (chainId) => {
+        this.ensureInitialized();
         return this.walletModule.getBlockNumber(chainId);
       },
       sendRawTransaction: (signedTx, chainId) => {
+        this.ensureInitialized();
         return this.walletModule.sendRawTransaction(signedTx, chainId);
       },
       getTransactionReceipt: (txHash, chainId) => {
+        this.ensureInitialized();
         return this.walletModule.getTransactionReceipt(txHash, chainId);
       },
       getTransaction: (txHash, chainId) => {
+        this.ensureInitialized();
         return this.walletModule.getTransaction(txHash, chainId);
       },
       estimateGas: (txParams, chainId) => {
+        this.ensureInitialized();
         return this.walletModule.estimateGas(txParams, chainId);
       },
       getGasPrice: (chainId) => {
+        this.ensureInitialized();
         return this.walletModule.getGasPrice(chainId);
       },
       call: (txParams, blockParam, chainId) => {
+        this.ensureInitialized();
         return this.walletModule.call(txParams, blockParam, chainId);
       }
     };
     this.network = {
-      getAvailableNetworks: () => this.networkModule.getAvailableNetworks(),
-      addNetwork: (request) => this.networkModule.addNetwork(request),
-      switchNetwork: (networkId) => this.networkModule.switchNetwork(networkId),
-      getCurrentNetwork: () => this.networkModule.getCurrentNetwork()
+      getAvailableNetworks: () => {
+        this.ensureInitialized();
+        return this.networkModule.getAvailableNetworks();
+      },
+      addNetwork: (request) => {
+        this.ensureInitialized();
+        return this.networkModule.addNetwork(request);
+      },
+      switchNetwork: (networkId) => {
+        this.ensureInitialized();
+        return this.networkModule.switchNetwork(networkId);
+      },
+      getCurrentNetwork: () => {
+        this.ensureInitialized();
+        return this.networkModule.getCurrentNetwork();
+      }
     };
     this.asset = {
       transfer: async (params) => {
+        this.ensureInitialized();
         return this.assetModule.transfer(params);
       },
       addToken: async (params) => {
+        this.ensureInitialized();
         return this.assetModule.addToken(params);
       },
       addNFTCollection: async (params) => {
+        this.ensureInitialized();
         return this.assetModule.addNFTCollection(params);
       },
       on: (event, listener) => {
+        this.ensureInitialized();
         this.assetModule.on(event, listener);
       },
       off: (event, listener) => {
+        this.ensureInitialized();
         this.assetModule.off(event, listener);
       },
       getTokenInfo: async (params) => {
+        this.ensureInitialized();
         return this.assetModule.getTokenInfo(params);
       },
       registerToken: async (params) => {
+        this.ensureInitialized();
         return this.assetModule.registerToken(params);
       },
       getTokenFullInfo: async (params) => {
+        this.ensureInitialized();
         return this.assetModule.getTokenFullInfo(params);
+      },
+      /**
+       * ✅ ERC20 잔액 조회 (주의: 현재 AssetModule 구현은 raw balance string을 반환)
+       * - TokenBalance(객체)가 아니라 string(wei) 입니다.
+       */
+      getTokenBalance: async (params) => {
+        this.ensureInitialized();
+        return this.assetModule.getTokenBalance(params);
+      },
+      approveToken: async (params) => {
+        this.ensureInitialized();
+        return this.assetModule.approveToken(params);
+      },
+      getAllowance: async (params) => {
+        this.ensureInitialized();
+        return this.assetModule.getAllowance(params);
+      }
+    };
+    /**
+     * ✅ NEW: Investment API Surface
+     */
+    this.invest = {
+      getOffering: async (params) => {
+        this.ensureInitialized();
+        return this.investmentModule.getOffering(params);
+      },
+      investRbtWithUsdr: async (params) => {
+        this.ensureInitialized();
+        return this.investmentModule.investRbtWithUsdr(params);
+      },
+      claimRbtRevenue: async (params) => {
+        this.ensureInitialized();
+        return this.investmentModule.claimRbtRevenue(params);
+      },
+      getClaimable: async (params) => {
+        this.ensureInitialized();
+        return this.investmentModule.getClaimable(params);
+      },
+      getRbtBalance: async (params) => {
+        this.ensureInitialized();
+        return this.investmentModule.getRbtBalance(params);
+      },
+      on: (event, listener) => {
+        this.ensureInitialized();
+        this.investmentModule.on(event, listener);
+      },
+      off: (event, listener) => {
+        this.ensureInitialized();
+        this.investmentModule.off(event, listener);
       }
     };
     this.validateOptions(options);
@@ -106808,6 +107309,7 @@ var WeBlockSDK = class {
     this.userModule = new UserModule(options, internalCore, this.walletModule);
     this.assetModule = new AssetModule(options, internalCore);
     this.networkModule = new NetworkModule(options, internalCore);
+    this.investmentModule = new InvestmentModule(options, internalCore);
     this.initialized = true;
     console.info("WeBlock SDK initialized successfully");
   }
@@ -106816,13 +107318,15 @@ var WeBlockSDK = class {
     if (!["local", "dev", "stage", "prod"].includes(environment)) {
       throw new SDKError("Invalid environment", "INVALID_CONFIG" /* INVALID_CONFIG */);
     }
-    if (!apiKey)
+    if (!apiKey) {
       throw new SDKError("API key is required", "INVALID_CONFIG" /* INVALID_CONFIG */);
-    if (!orgHost)
+    }
+    if (!orgHost) {
       throw new SDKError(
         "Organization host is required",
         "INVALID_CONFIG" /* INVALID_CONFIG */
       );
+    }
   }
   ensureInitialized() {
     if (!this.initialized) {