@hardkas/kaspa-rpc 0.8.4-alpha → 0.8.9-alpha

package/dist/index.d.ts

@@ -275,7 +275,7 @@ interface KaspaRpcClient {
     healthCheck(): Promise<KaspaRpcHealth>;
     getBalanceByAddress(address: string): Promise<KaspaAddressBalance>;
     getUtxosByAddress(address: string): Promise<KaspaRpcUtxo[]>;
-    submitTransaction(rawTransaction: string): Promise<KaspaSubmitTransactionResult>;
+    submitTransaction(rawTransaction: unknown): Promise<KaspaSubmitTransactionResult>;
     getMempoolEntry(txId: string): Promise<MempoolEntry | null>;
     getTransaction(txId: string): Promise<unknown | null>;
     getBlockDagInfo(): Promise<BlockDagInfo>;
@@ -288,18 +288,21 @@ declare class JsonWrpcKaspaClient implements KaspaRpcClient {
     private readonly timeoutMs;
     private requestId;
     constructor(options: JsonWrpcKaspaClientOptions);
+    private rpcFlavor;
+    private preflightPromise;
+    private detectFlavor;
+    private callMethod;
     getInfo(): Promise<KaspaNodeInfo>;
     healthCheck(): Promise<KaspaRpcHealth>;
     getBalanceByAddress(address: string): Promise<KaspaAddressBalance>;
     getUtxosByAddress(address: string): Promise<KaspaRpcUtxo[]>;
-    submitTransaction(rawTransaction: string): Promise<KaspaSubmitTransactionResult>;
+    submitTransaction(rawTransaction: unknown): Promise<KaspaSubmitTransactionResult>;
     getMempoolEntry(txId: string): Promise<MempoolEntry | null>;
     getTransaction(txId: string): Promise<unknown | null>;
     getBlockDagInfo(): Promise<BlockDagInfo>;
     getServerInfo(): Promise<ServerInfo>;
     close(): Promise<void>;
-    private safeRequest;
-    private request;
+    private requestRaw;
     private connect;
 }
 declare function mapKaspaNodeInfo(result: any): KaspaNodeInfo;
@@ -315,7 +318,7 @@ declare class MockKaspaRpcClient implements KaspaRpcClient {
     getBalanceByAddress(address: string): Promise<KaspaAddressBalance>;
     getUtxosByAddress(address: string): Promise<KaspaRpcUtxo[]>;
     setUtxos(address: string, utxos: KaspaRpcUtxo[]): void;
-    submitTransaction(rawTransaction: string): Promise<KaspaSubmitTransactionResult>;
+    submitTransaction(rawTransaction: unknown): Promise<KaspaSubmitTransactionResult>;
     getMempoolEntry(_txId: string): Promise<MempoolEntry | null>;
     getTransaction(_txId: string): Promise<unknown | null>;
     getBlockDagInfo(): Promise<BlockDagInfo>;

package/dist/index.js

@@ -310,8 +310,51 @@ var KaspaJsonRpcClient = class {
     }
   }
   async submitTransaction(rawTx) {
+    let txObj = rawTx;
+    try {
+      while (typeof txObj === "string" && txObj.startsWith("{")) {
+        const parsed = JSON.parse(txObj);
+        if (parsed && typeof parsed === "object") {
+          if ("tx" in parsed) txObj = parsed.tx;
+          else if ("inner" in parsed) txObj = parsed.inner;
+          else txObj = parsed;
+        } else {
+          txObj = parsed;
+        }
+      }
+      while (txObj && typeof txObj === "object" && !Array.isArray(txObj) && ("tx" in txObj || "inner" in txObj)) {
+        if ("tx" in txObj) txObj = txObj.tx;
+        else if ("inner" in txObj) txObj = txObj.inner;
+      }
+      const txAny = txObj;
+      if (txAny && typeof txAny === "object") {
+        txAny.mass = txAny.mass || 0;
+        if (txAny.payload === void 0) txAny.payload = "";
+        if (txAny.outputs && Array.isArray(txAny.outputs)) {
+          txAny.outputs.forEach((output) => {
+            const amount = output.amount !== void 0 ? output.amount : output.value;
+            output.value = typeof amount === "string" ? Number(amount) : amount;
+            delete output.amount;
+            if (output.scriptPublicKey && typeof output.scriptPublicKey === "object") {
+              const spk = output.scriptPublicKey;
+              const versionHex = (spk.version || 0).toString(16).padStart(4, "0");
+              const scriptHex = spk.script || spk.scriptPublicKey || "";
+              output.scriptPublicKey = versionHex + scriptHex;
+            }
+          });
+        }
+        if (txAny.inputs && Array.isArray(txAny.inputs)) {
+          txAny.inputs.forEach((input) => {
+            if (typeof input.sequence === "string") input.sequence = Number(input.sequence);
+            if (typeof input.sigOpCount === "string") input.sigOpCount = Number(input.sigOpCount);
+          });
+        }
+      }
+    } catch (e) {
+    }
     const result = await this.callRpc("submitTransactionRequest", {
-      transaction: rawTx
+      transaction: txObj,
+      allowOrphan: false
     });
     return { transactionId: result.transactionId };
   }
@@ -778,27 +821,40 @@ var JsonWrpcKaspaClient = class {
     this.rpcUrl = options.rpcUrl;
     this.timeoutMs = options.timeoutMs ?? 1e4;
   }
+  rpcFlavor = null;
+  preflightPromise = null;
+  async detectFlavor() {
+    if (this.rpcFlavor) return;
+    if (this.preflightPromise) return this.preflightPromise;
+    this.preflightPromise = (async () => {
+      try {
+        const ws = await this.connect();
+        const res = await this.requestRaw("getServerInfo", {});
+        this.rpcFlavor = "wrpc";
+      } catch (e) {
+        if (e.message && e.message.includes("Method not found")) {
+          this.rpcFlavor = "legacy";
+        } else {
+          this.rpcFlavor = "wrpc";
+        }
+      }
+    })();
+    return this.preflightPromise;
+  }
+  async callMethod(wrpcName, legacyName, params = {}) {
+    await this.detectFlavor();
+    const method = this.rpcFlavor === "legacy" ? legacyName : wrpcName;
+    return this.requestRaw(method, params);
+  }
   async getInfo() {
-    const response = await this.safeRequest([
-      "getInfo",
-      "getInfoRequest",
-      "GetInfo",
-      "get_info"
-    ]);
+    const response = await this.callMethod("getInfo", "getInfoRequest");
     const info = mapKaspaNodeInfo(response);
     if (info.virtualDaaScore === void 0) {
       try {
-        const dagResponse = await this.safeRequest([
-          "getBlockDagInfo",
-          "getBlockDagInfoRequest",
-          "GetBlockDagInfo",
-          "get_block_dag_info"
-        ]);
+        const dagResponse = await this.callMethod("getBlockDagInfo", "getBlockDagInfoRequest");
         const dagData = dagResponse?.params || dagResponse;
         if (dagData && typeof dagData === "object" && "virtualDaaScore" in dagData) {
-          info.virtualDaaScore = BigInt(
-            dagData.virtualDaaScore
-          );
+          info.virtualDaaScore = BigInt(dagData.virtualDaaScore);
         }
       } catch (e) {
       }
@@ -824,55 +880,61 @@ var JsonWrpcKaspaClient = class {
     }
   }
   async getBalanceByAddress(address) {
-    const response = await this.safeRequest(
-      [
-        "getBalancesByAddresses",
-        "getBalancesByAddressesRequest",
-        "getBalanceByAddressRequest",
-        "GetBalancesByAddresses",
-        "get_balances_by_addresses",
-        "GetBalanceByAddress",
-        "getBalanceByAddress",
-        "get_balance_by_address"
-      ],
-      { addresses: [address], address }
-    );
+    await this.detectFlavor();
+    let response;
+    if (this.rpcFlavor === "legacy") {
+      response = await this.callMethod("getBalanceByAddress", "getBalanceByAddressRequest", { address });
+    } else {
+      response = await this.callMethod("getBalancesByAddresses", "getBalancesByAddressesRequest", { addresses: [address] });
+    }
     return mapKaspaAddressBalance(response, address);
   }
   async getUtxosByAddress(address) {
-    const response = await this.safeRequest(
-      [
-        "getUtxosByAddresses",
-        "getUtxosByAddressesRequest",
-        "getUtxosByAddressRequest",
-        "GetUtxosByAddresses",
-        "get_utxos_by_addresses",
-        "GetUtxosByAddress",
-        "getUtxosByAddress",
-        "get_utxos_by_address"
-      ],
-      { addresses: [address], address }
-    );
+    const response = await this.callMethod("getUtxosByAddresses", "getUtxosByAddressesRequest", { addresses: [address] });
     return mapKaspaRpcUtxos(response, address);
   }
   async submitTransaction(rawTransaction) {
-    const response = await this.safeRequest(
-      [
-        "submitTransaction",
-        "submitTransactionRequest",
-        "SubmitTransaction",
-        "submit_transaction"
-      ],
-      { transaction: rawTransaction, transactionHex: rawTransaction, rawTransaction }
-    );
+    let txObj = rawTransaction;
+    try {
+      while (typeof txObj === "string" && txObj.startsWith("{")) {
+        const parsed = JSON.parse(txObj);
+        if (parsed && typeof parsed === "object") {
+          if ("tx" in parsed) txObj = parsed.tx;
+          else if ("inner" in parsed) txObj = parsed.inner;
+          else txObj = parsed;
+        } else {
+          txObj = parsed;
+        }
+      }
+      while (txObj && typeof txObj === "object" && !Array.isArray(txObj) && ("tx" in txObj || "inner" in txObj)) {
+        if ("tx" in txObj) txObj = txObj.tx;
+        else if ("inner" in txObj) txObj = txObj.inner;
+      }
+      const txAny = txObj;
+      if (txAny && typeof txAny === "object" && txAny.outputs && Array.isArray(txAny.outputs)) {
+        txAny.outputs.forEach((output) => {
+          if (typeof output.amount === "string") {
+            output.amount = Number(output.amount);
+          }
+          if (typeof output.value === "string") {
+            output.value = Number(output.value);
+          }
+        });
+      }
+      if (txAny && typeof txAny === "object" && txAny.inputs && Array.isArray(txAny.inputs)) {
+        txAny.inputs.forEach((input) => {
+          if (typeof input.sequence === "string") input.sequence = Number(input.sequence);
+          if (typeof input.sigOpCount === "string") input.sigOpCount = Number(input.sigOpCount);
+        });
+      }
+    } catch (e) {
+    }
+    const response = await this.callMethod("submitTransaction", "submitTransactionRequest", { transaction: txObj, allowOrphan: false });
     return mapKaspaSubmitTransactionResult(response);
   }
   async getMempoolEntry(txId) {
     try {
-      const response = await this.safeRequest(
-        ["getMempoolEntryRequest", "getMempoolEntry"],
-        { txId, transactionId: txId }
-      );
+      const response = await this.callMethod("getMempoolEntry", "getMempoolEntryRequest", { transactionId: txId, includeOrphanPool: true, filterTransactionPool: false });
       if (!response) return null;
       const resObj = response;
       return {
@@ -885,11 +947,7 @@ var JsonWrpcKaspaClient = class {
   }
   async getTransaction(txId) {
     try {
-      const response = await this.safeRequest(
-        ["getTransactionRequest", "getTransaction"],
-        { txId, transactionId: txId }
-      );
-      return response;
+      return await this.callMethod("getTransaction", "getTransactionRequest", { transactionId: txId });
     } catch (e) {
       return null;
     }
@@ -920,41 +978,7 @@ var JsonWrpcKaspaClient = class {
       this.socket = null;
     }
   }
-  async safeRequest(methods, params = {}) {
-    let lastError = null;
-    for (const method of methods) {
-      try {
-        let actualParams = params;
-        const lowerMethod = method.toLowerCase();
-        const pObj = params;
-        if (lowerMethod.includes("addresses") || lowerMethod.endsWith("s")) {
-          if (pObj.address && !pObj.addresses) {
-            actualParams = { addresses: [pObj.address] };
-          } else if (pObj.addresses) {
-            actualParams = { addresses: pObj.addresses };
-          }
-        } else if (pObj.addresses && !pObj.address) {
-          actualParams = { address: pObj.addresses[0] };
-        } else if (pObj.address) {
-          actualParams = { address: pObj.address };
-        }
-        try {
-          return await this.request(method, actualParams);
-        } catch (e) {
-          if (e.message?.includes("deserialization")) {
-            const arrayParams = Object.values(actualParams);
-            return await this.request(method, arrayParams);
-          }
-          throw e;
-        }
-      } catch (error) {
-        lastError = error;
-        continue;
-      }
-    }
-    throw lastError ?? new Error(`Methods failed: ${methods.join(", ")}`);
-  }
-  async request(method, params = {}) {
+  async requestRaw(method, params = {}) {
     const ws = await this.connect();
     const id = this.requestId++;
     const payload = JSON.stringify({
@@ -1112,7 +1136,7 @@ function mapKaspaSubmitTransactionResult(result) {
   if (!result) return { raw: result };
   return {
     transactionId: result.transactionId || result.transaction_id || result.txId || result.tx_id,
-    accepted: result.accepted !== void 0 ? result.accepted : result.isAccepted || result.success,
+    accepted: result.accepted !== void 0 ? result.accepted : result.isAccepted !== void 0 ? result.isAccepted : result.success !== void 0 ? result.success : !!(result.transactionId || result.transaction_id || result.txId || result.tx_id),
     raw: result
   };
 }

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@hardkas/kaspa-rpc",
-  "version": "0.8.4-alpha",
+  "version": "0.8.9-alpha",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "dependencies": {
     "ws": "^8.18.0",
-    "@hardkas/core": "0.8.4-alpha",
-    "@hardkas/tx-builder": "0.8.4-alpha"
+    "@hardkas/core": "0.8.9-alpha",
+    "@hardkas/tx-builder": "0.8.9-alpha"
   },
   "devDependencies": {
     "@types/ws": "^8.5.13",