@weblock-wallet/sdk 0.1.52 → 0.1.53

package/dist/index.cjs

@@ -105236,6 +105236,44 @@ var ERC20_ABI2 = [
     type: "function"
   }
 ];
+var ERC1155_ABI = [
+  {
+    constant: true,
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "id", type: "uint256" }
+    ],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var RBT_PROPERTY_TOKEN_ABI = [
+  ...ERC1155_ABI,
+  {
+    constant: true,
+    inputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "account", type: "address" }
+    ],
+    name: "claimable",
+    outputs: [{ name: "", type: "uint256" }],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    name: "claim",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
 
 // src/core/services/asset.ts
 var import_ethers3 = require("ethers");
@@ -105920,6 +105958,7 @@ var AssetService = class extends EventEmitter {
     this.orgHost = orgHost;
     this.chainIdCache = /* @__PURE__ */ new Map();
     this.erc20Interface = new import_ethers3.Interface(ERC20_ABI2);
+    this.rbtInterface = new import_ethers3.Interface(RBT_PROPERTY_TOKEN_ABI);
   }
   /**
    * Resolve a user-facing networkId (blockchainId) into an EVM chainId for /v1/rpcs.
@@ -106217,21 +106256,116 @@ var AssetService = class extends EventEmitter {
       );
     }
   }
-  async approveToken(params) {
+  /**
+   * ERC-1155 balanceOf(account, tokenId)
+   * - Returns raw hex string (0x...)
+   */
+  async getERC1155Balance(params) {
     try {
       const chainId = await this.resolveChainId(params.networkId);
-      const data = this.erc20Interface.encodeFunctionData("approve", [
-        params.spender,
-        params.amount
+      const data = this.rbtInterface.encodeFunctionData("balanceOf", [
+        params.walletAddress,
+        params.tokenId
+      ]);
+      const response = await this.rpcClient.sendRpc({
+        chainId,
+        method: "eth_call" /* ETH_CALL */,
+        params: [
+          {
+            to: params.tokenAddress,
+            data
+          },
+          "latest"
+        ]
+      });
+      return response.result;
+    } catch (error) {
+      throw new SDKError(
+        "Failed to get ERC1155 balance",
+        "REQUEST_FAILED" /* REQUEST_FAILED */,
+        error
+      );
+    }
+  }
+  /**
+   * RBTPropertyToken claimable(tokenId, account)
+   * - Returns raw hex string (0x...)
+   */
+  async getRbtClaimable(params) {
+    try {
+      const chainId = await this.resolveChainId(params.networkId);
+      const data = this.rbtInterface.encodeFunctionData("claimable", [
+        params.tokenId,
+        params.walletAddress
+      ]);
+      const response = await this.rpcClient.sendRpc({
+        chainId,
+        method: "eth_call" /* ETH_CALL */,
+        params: [
+          {
+            to: params.tokenAddress,
+            data
+          },
+          "latest"
+        ]
+      });
+      return response.result;
+    } catch (error) {
+      throw new SDKError(
+        "Failed to get claimable amount",
+        "REQUEST_FAILED" /* REQUEST_FAILED */,
+        error
+      );
+    }
+  }
+  /**
+   * RBTPropertyToken claim(tokenId)
+   * - Sends a signed transaction via WalletService
+   * - Returns txHash
+   */
+  async claimRbt(params) {
+    try {
+      const chainId = await this.resolveChainId(params.networkId);
+      const data = this.rbtInterface.encodeFunctionData("claim", [
+        params.tokenId
       ]);
       const txHash = await this.walletService.sendTransaction({
         to: params.tokenAddress,
         value: "0",
         data,
-        chainId
+        chainId,
+        gasLimit: params.gasLimit,
+        gasPrice: params.gasPrice,
+        nonce: params.nonce
       });
       this.trackTransaction(txHash, chainId);
       return txHash;
+    } catch (error) {
+      throw new SDKError(
+        "Failed to claim RBT",
+        "REQUEST_FAILED" /* REQUEST_FAILED */,
+        error
+      );
+    }
+  }
+  async approveToken(params) {
+    try {
+      const chainId = await this.resolveChainId(params.networkId);
+      const data = this.erc20Interface.encodeFunctionData("approve", [
+        params.spender,
+        params.amount
+      ]);
+      const response = await this.rpcClient.sendRpc({
+        chainId,
+        method: "eth_sendRawTransaction" /* ETH_SEND_RAW_TRANSACTION */,
+        params: [
+          {
+            to: params.tokenAddress,
+            data
+          }
+        ]
+      });
+      return response.result;
     } catch (error) {
       throw new SDKError(
         "Failed to approve token",
@@ -106314,402 +106448,6 @@ var AssetService = class extends EventEmitter {
   // }
 };
 
-// src/core/services/investment.ts
-var import_ethers4 = require("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 import_ethers4.Interface(ERC20_ABI2);
-    this.saleInterface = new import_ethers4.Interface(RBT_PRIMARY_SALE_ROUTER_ABI);
-    this.rbtInterface = new import_ethers4.Interface(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) {
@@ -106749,9 +106487,22 @@ var InternalCoreImpl = class {
       addToken: (params) => this.assetService.addToken(params),
       // New ERC20 methods
       getTokenBalance: (params) => this.assetService.getTokenBalance(params),
+      // ERC1155 / RBT helpers
+      getERC1155Balance: (params) => this.assetService.getERC1155Balance(params),
+      getRbtClaimable: (params) => this.assetService.getRbtClaimable(params),
+      claimRbt: (params) => this.assetService.claimRbt(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),
@@ -106759,15 +106510,6 @@ 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);
@@ -106793,11 +106535,6 @@ var InternalCoreImpl = class {
       userClient,
       options.orgHost
     );
-    this.investmentService = new InvestmentService(
-      rpcClient,
-      this.walletService,
-      this.networkService
-    );
   }
 };
 
@@ -107050,6 +106787,15 @@ var AssetModule = class {
   async getTokenBalance(params) {
     return this.core.asset.getTokenBalance(params);
   }
+  async getERC1155Balance(params) {
+    return this.core.asset.getERC1155Balance(params);
+  }
+  async getRbtClaimable(params) {
+    return this.core.asset.getRbtClaimable(params);
+  }
+  async claimRbt(params) {
+    return this.core.asset.claimRbt(params);
+  }
   async approveToken(params) {
     return this.core.asset.approveToken(params);
   }
@@ -107073,35 +106819,6 @@ 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: {
@@ -107169,134 +106886,88 @@ 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.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();
-      }
+      getAvailableNetworks: () => this.networkModule.getAvailableNetworks(),
+      addNetwork: (request) => this.networkModule.addNetwork(request),
+      switchNetwork: (networkId) => this.networkModule.switchNetwork(networkId),
+      getCurrentNetwork: () => 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) 입니다.
-       */
+      // ERC20 helpers
       getTokenBalance: async (params) => {
         this.ensureInitialized();
         return this.assetModule.getTokenBalance(params);
@@ -107308,39 +106979,25 @@ var WeBlockSDK = class {
       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) => {
+      // ERC1155 / RBT helpers
+      getERC1155Balance: async (params) => {
         this.ensureInitialized();
-        return this.investmentModule.investRbtWithUsdr(params);
+        return this.assetModule.getERC1155Balance(params);
       },
-      claimRbtRevenue: async (params) => {
+      getRbtClaimable: async (params) => {
         this.ensureInitialized();
-        return this.investmentModule.claimRbtRevenue(params);
+        return this.assetModule.getRbtClaimable(params);
       },
-      getClaimable: async (params) => {
+      claimRbt: async (params) => {
         this.ensureInitialized();
-        return this.investmentModule.getClaimable(params);
+        return this.assetModule.claimRbt(params);
       },
-      getRbtBalance: async (params) => {
-        this.ensureInitialized();
-        return this.investmentModule.getRbtBalance(params);
-      },
-      on: (event, listener) => {
-        this.ensureInitialized();
-        this.investmentModule.on(event, listener);
+      registerToken: async (params) => {
+        return this.assetModule.registerToken(params);
       },
-      off: (event, listener) => {
-        this.ensureInitialized();
-        this.investmentModule.off(event, listener);
+      getTokenFullInfo: async (params) => {
+        return this.assetModule.getTokenFullInfo(params);
       }
     };
     this.validateOptions(options);
@@ -107350,7 +107007,6 @@ 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");
   }
@@ -107359,15 +107015,13 @@ 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) {