@phantom/parsers 0.0.4 → 0.0.6

package/README.md

@@ -169,6 +169,10 @@ The parsers automatically detect the input format and handle conversion appropri
 - **Hex strings** - "0x"-prefixed hex-encoded transaction data
 - **Base64/Base64url** - Already encoded transaction data
 
+## Cross-Platform Compatibility
+
+The parsers package is designed to work across different JavaScript environments including browsers, Node.js, and React Native. The package gracefully handles missing dependencies and provides consistent parsing functionality across all supported platforms.
+
 ## Error Handling
 
 The parsers will throw descriptive errors for:
@@ -220,8 +224,28 @@ yarn build
 
 # Run tests
 yarn test
+
+# Run integration tests (requires RPC access)
+yarn test:integration
 ```
 
+### Integration Tests
+
+The package includes comprehensive integration tests that create real transactions using actual Solana libraries:
+
+- **VersionedTransaction** parsing with `@solana/web3.js`
+- **Legacy Transaction** parsing with `@solana/web3.js`
+- **@solana/kit** transaction parsing
+- Error handling and network resilience
+
+To run integration tests:
+
+1. Copy `.env.example` to `.env`
+2. Set `SOLANA_RPC_URL` to your preferred Solana RPC endpoint
+3. Run `yarn test:integration`
+
+**Note**: Integration tests make real network calls to fetch recent blockhashes but only create local test transactions (no funds required).
+
 ## License
 
 MIT License - see LICENSE file for details.

package/dist/index.d.ts

@@ -1,4 +1,28 @@
-import { NetworkId } from '@phantom/client';
+import { NetworkId } from '@phantom/constants';
+
+/**
+ * Chain-specific transaction and message response parsing
+ * This module contains the specific parsing logic for each blockchain network
+ */
+
+interface ParsedSignatureResult {
+    signature: string;
+    rawSignature: string;
+    blockExplorer?: string;
+}
+interface ParsedTransactionResult {
+    hash?: string;
+    rawTransaction: string;
+    blockExplorer?: string;
+}
+/**
+ * Parse a signed message response from base64 to human-readable format
+ */
+declare function parseSignMessageResponse(base64Response: string, networkId: NetworkId): ParsedSignatureResult;
+/**
+ * Parse a transaction response from base64 rawTransaction to extract hash
+ */
+declare function parseTransactionResponse(base64RawTransaction: string, networkId: NetworkId, hash?: string): ParsedTransactionResult;
 
 interface ParsedTransaction {
     base64url: string;
@@ -7,6 +31,7 @@ interface ParsedTransaction {
 interface ParsedMessage {
     base64url: string;
 }
+
 /**
  * Parse a message to base64url format for the client
  */
@@ -16,4 +41,4 @@ declare function parseMessage(message: string): ParsedMessage;
  */
 declare function parseTransaction(transaction: any, networkId: NetworkId): Promise<ParsedTransaction>;
 
-export { ParsedMessage, ParsedTransaction, parseMessage, parseTransaction };
+export { ParsedMessage, ParsedSignatureResult, ParsedTransaction, ParsedTransactionResult, parseMessage, parseSignMessageResponse, parseTransaction, parseTransactionResponse };

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,20 +17,133 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   parseMessage: () => parseMessage,
-  parseTransaction: () => parseTransaction
+  parseSignMessageResponse: () => parseSignMessageResponse,
+  parseTransaction: () => parseTransaction,
+  parseTransactionResponse: () => parseTransactionResponse
 });
 module.exports = __toCommonJS(src_exports);
+var import_base64url2 = require("@phantom/base64url");
+var import_buffer2 = require("buffer");
+
+// src/response-parsers.ts
+var import_constants = require("@phantom/constants");
 var import_base64url = require("@phantom/base64url");
 var import_buffer = require("buffer");
+var import_bs58 = __toESM(require("bs58"));
+function parseSignMessageResponse(base64Response, networkId) {
+  const networkPrefix = networkId.split(":")[0].toLowerCase();
+  switch (networkPrefix) {
+    case "solana":
+      return parseSolanaSignatureResponse(base64Response);
+    case "eip155":
+    case "ethereum":
+      return parseEVMSignatureResponse(base64Response);
+    case "sui":
+      return parseSuiSignatureResponse(base64Response);
+    case "bip122":
+    case "bitcoin":
+      return parseBitcoinSignatureResponse(base64Response);
+    default:
+      return {
+        signature: base64Response,
+        rawSignature: base64Response
+      };
+  }
+}
+function parseTransactionResponse(base64RawTransaction, networkId, hash) {
+  if (hash) {
+    return {
+      hash,
+      rawTransaction: base64RawTransaction,
+      blockExplorer: (0, import_constants.getExplorerUrl)(networkId, "transaction", hash)
+    };
+  } else {
+    return {
+      rawTransaction: base64RawTransaction
+    };
+  }
+}
+function parseSolanaSignatureResponse(base64Response) {
+  try {
+    const signatureBytes = (0, import_base64url.base64urlDecode)(base64Response);
+    const signature = import_bs58.default.encode(signatureBytes);
+    return {
+      signature,
+      rawSignature: base64Response
+    };
+  } catch (error) {
+    return {
+      signature: base64Response,
+      rawSignature: base64Response
+    };
+  }
+}
+function parseEVMSignatureResponse(base64Response) {
+  try {
+    const signatureBytes = (0, import_base64url.base64urlDecode)(base64Response);
+    const signature = "0x" + import_buffer.Buffer.from(signatureBytes).toString("hex");
+    return {
+      signature,
+      rawSignature: base64Response
+      // Note: Most block explorers don't have direct signature lookup, only transaction lookup
+    };
+  } catch (error) {
+    const signature = base64Response.startsWith("0x") ? base64Response : "0x" + base64Response;
+    return {
+      signature,
+      rawSignature: base64Response
+    };
+  }
+}
+function parseSuiSignatureResponse(base64Response) {
+  try {
+    const signatureBytes = (0, import_base64url.base64urlDecode)(base64Response);
+    const signature = import_buffer.Buffer.from(signatureBytes).toString("base64");
+    return {
+      signature,
+      rawSignature: base64Response
+    };
+  } catch (error) {
+    return {
+      signature: base64Response,
+      rawSignature: base64Response
+    };
+  }
+}
+function parseBitcoinSignatureResponse(base64Response) {
+  try {
+    const signatureBytes = (0, import_base64url.base64urlDecode)(base64Response);
+    const signature = import_buffer.Buffer.from(signatureBytes).toString("hex");
+    return {
+      signature,
+      rawSignature: base64Response
+    };
+  } catch (error) {
+    return {
+      signature: base64Response,
+      rawSignature: base64Response
+    };
+  }
+}
+
+// src/index.ts
 function parseMessage(message) {
   return {
-    base64url: (0, import_base64url.stringToBase64url)(message)
+    base64url: (0, import_base64url2.stringToBase64url)(message)
   };
 }
 async function parseTransaction(transaction, networkId) {
@@ -54,7 +169,7 @@ async function parseTransaction(transaction, networkId) {
 function parseSolanaTransaction(transaction) {
   if (transaction?.messageBytes != null) {
     return {
-      base64url: (0, import_base64url.base64urlEncode)(transaction.messageBytes),
+      base64url: (0, import_base64url2.base64urlEncode)(transaction.messageBytes),
       originalFormat: "@solana/kit"
     };
   }
@@ -64,21 +179,21 @@ function parseSolanaTransaction(transaction) {
       verifySignatures: false
     });
     return {
-      base64url: (0, import_base64url.base64urlEncode)(serialized),
+      base64url: (0, import_base64url2.base64urlEncode)(serialized),
       originalFormat: "@solana/web3.js"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: (0, import_base64url.base64urlEncode)(transaction),
+      base64url: (0, import_base64url2.base64urlEncode)(transaction),
       originalFormat: "bytes"
     };
   }
   if (typeof transaction === "string") {
     try {
-      const bytes = import_buffer.Buffer.from(transaction, "base64");
+      const bytes = import_buffer2.Buffer.from(transaction, "base64");
       return {
-        base64url: (0, import_base64url.base64urlEncode)(new Uint8Array(bytes)),
+        base64url: (0, import_base64url2.base64urlEncode)(new Uint8Array(bytes)),
         originalFormat: "base64"
       };
     } catch {
@@ -93,28 +208,28 @@ function parseEVMTransaction(transaction) {
       JSON.stringify(transaction, (_key, value) => typeof value === "bigint" ? value.toString() : value)
     );
     return {
-      base64url: (0, import_base64url.base64urlEncode)(bytes),
+      base64url: (0, import_base64url2.base64urlEncode)(bytes),
       originalFormat: "viem"
     };
   }
   if (transaction?.serialize && typeof transaction.serialize === "function") {
     const serialized = transaction.serialize();
-    const bytes = new Uint8Array(import_buffer.Buffer.from(serialized.slice(2), "hex"));
+    const bytes = new Uint8Array(import_buffer2.Buffer.from(serialized.slice(2), "hex"));
     return {
-      base64url: (0, import_base64url.base64urlEncode)(bytes),
+      base64url: (0, import_base64url2.base64urlEncode)(bytes),
       originalFormat: "ethers"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: (0, import_base64url.base64urlEncode)(transaction),
+      base64url: (0, import_base64url2.base64urlEncode)(transaction),
       originalFormat: "bytes"
     };
   }
   if (typeof transaction === "string" && transaction.startsWith("0x")) {
-    const bytes = new Uint8Array(import_buffer.Buffer.from(transaction.slice(2), "hex"));
+    const bytes = new Uint8Array(import_buffer2.Buffer.from(transaction.slice(2), "hex"));
     return {
-      base64url: (0, import_base64url.base64urlEncode)(bytes),
+      base64url: (0, import_base64url2.base64urlEncode)(bytes),
       originalFormat: "hex"
     };
   }
@@ -124,13 +239,13 @@ async function parseSuiTransaction(transaction) {
   if (transaction?.serialize && typeof transaction.serialize === "function") {
     const serialized = transaction.serialize();
     return {
-      base64url: (0, import_base64url.base64urlEncode)(serialized),
+      base64url: (0, import_base64url2.base64urlEncode)(serialized),
       originalFormat: "sui-sdk"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: (0, import_base64url.base64urlEncode)(transaction),
+      base64url: (0, import_base64url2.base64urlEncode)(transaction),
       originalFormat: "bytes"
     };
   }
@@ -139,7 +254,7 @@ async function parseSuiTransaction(transaction) {
     if (built?.serialize && typeof built.serialize === "function") {
       const serialized = built.serialize();
       return {
-        base64url: (0, import_base64url.base64urlEncode)(serialized),
+        base64url: (0, import_base64url2.base64urlEncode)(serialized),
         originalFormat: "transaction-block"
       };
     }
@@ -150,20 +265,20 @@ function parseBitcoinTransaction(transaction) {
   if (transaction?.toBuffer && typeof transaction.toBuffer === "function") {
     const buffer = transaction.toBuffer();
     return {
-      base64url: (0, import_base64url.base64urlEncode)(new Uint8Array(buffer)),
+      base64url: (0, import_base64url2.base64urlEncode)(new Uint8Array(buffer)),
       originalFormat: "bitcoinjs-lib"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: (0, import_base64url.base64urlEncode)(transaction),
+      base64url: (0, import_base64url2.base64urlEncode)(transaction),
       originalFormat: "bytes"
     };
   }
   if (typeof transaction === "string") {
-    const bytes = new Uint8Array(import_buffer.Buffer.from(transaction, "hex"));
+    const bytes = new Uint8Array(import_buffer2.Buffer.from(transaction, "hex"));
     return {
-      base64url: (0, import_base64url.base64urlEncode)(bytes),
+      base64url: (0, import_base64url2.base64urlEncode)(bytes),
       originalFormat: "hex"
     };
   }
@@ -172,5 +287,7 @@ function parseBitcoinTransaction(transaction) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   parseMessage,
-  parseTransaction
+  parseSignMessageResponse,
+  parseTransaction,
+  parseTransactionResponse
 });

package/dist/index.mjs

@@ -1,6 +1,109 @@
 // src/index.ts
 import { base64urlEncode, stringToBase64url } from "@phantom/base64url";
+import { Buffer as Buffer2 } from "buffer";
+
+// src/response-parsers.ts
+import { getExplorerUrl } from "@phantom/constants";
+import { base64urlDecode } from "@phantom/base64url";
 import { Buffer } from "buffer";
+import bs58 from "bs58";
+function parseSignMessageResponse(base64Response, networkId) {
+  const networkPrefix = networkId.split(":")[0].toLowerCase();
+  switch (networkPrefix) {
+    case "solana":
+      return parseSolanaSignatureResponse(base64Response);
+    case "eip155":
+    case "ethereum":
+      return parseEVMSignatureResponse(base64Response);
+    case "sui":
+      return parseSuiSignatureResponse(base64Response);
+    case "bip122":
+    case "bitcoin":
+      return parseBitcoinSignatureResponse(base64Response);
+    default:
+      return {
+        signature: base64Response,
+        rawSignature: base64Response
+      };
+  }
+}
+function parseTransactionResponse(base64RawTransaction, networkId, hash) {
+  if (hash) {
+    return {
+      hash,
+      rawTransaction: base64RawTransaction,
+      blockExplorer: getExplorerUrl(networkId, "transaction", hash)
+    };
+  } else {
+    return {
+      rawTransaction: base64RawTransaction
+    };
+  }
+}
+function parseSolanaSignatureResponse(base64Response) {
+  try {
+    const signatureBytes = base64urlDecode(base64Response);
+    const signature = bs58.encode(signatureBytes);
+    return {
+      signature,
+      rawSignature: base64Response
+    };
+  } catch (error) {
+    return {
+      signature: base64Response,
+      rawSignature: base64Response
+    };
+  }
+}
+function parseEVMSignatureResponse(base64Response) {
+  try {
+    const signatureBytes = base64urlDecode(base64Response);
+    const signature = "0x" + Buffer.from(signatureBytes).toString("hex");
+    return {
+      signature,
+      rawSignature: base64Response
+      // Note: Most block explorers don't have direct signature lookup, only transaction lookup
+    };
+  } catch (error) {
+    const signature = base64Response.startsWith("0x") ? base64Response : "0x" + base64Response;
+    return {
+      signature,
+      rawSignature: base64Response
+    };
+  }
+}
+function parseSuiSignatureResponse(base64Response) {
+  try {
+    const signatureBytes = base64urlDecode(base64Response);
+    const signature = Buffer.from(signatureBytes).toString("base64");
+    return {
+      signature,
+      rawSignature: base64Response
+    };
+  } catch (error) {
+    return {
+      signature: base64Response,
+      rawSignature: base64Response
+    };
+  }
+}
+function parseBitcoinSignatureResponse(base64Response) {
+  try {
+    const signatureBytes = base64urlDecode(base64Response);
+    const signature = Buffer.from(signatureBytes).toString("hex");
+    return {
+      signature,
+      rawSignature: base64Response
+    };
+  } catch (error) {
+    return {
+      signature: base64Response,
+      rawSignature: base64Response
+    };
+  }
+}
+
+// src/index.ts
 function parseMessage(message) {
   return {
     base64url: stringToBase64url(message)
@@ -51,7 +154,7 @@ function parseSolanaTransaction(transaction) {
   }
   if (typeof transaction === "string") {
     try {
-      const bytes = Buffer.from(transaction, "base64");
+      const bytes = Buffer2.from(transaction, "base64");
       return {
         base64url: base64urlEncode(new Uint8Array(bytes)),
         originalFormat: "base64"
@@ -74,7 +177,7 @@ function parseEVMTransaction(transaction) {
   }
   if (transaction?.serialize && typeof transaction.serialize === "function") {
     const serialized = transaction.serialize();
-    const bytes = new Uint8Array(Buffer.from(serialized.slice(2), "hex"));
+    const bytes = new Uint8Array(Buffer2.from(serialized.slice(2), "hex"));
     return {
       base64url: base64urlEncode(bytes),
       originalFormat: "ethers"
@@ -87,7 +190,7 @@ function parseEVMTransaction(transaction) {
     };
   }
   if (typeof transaction === "string" && transaction.startsWith("0x")) {
-    const bytes = new Uint8Array(Buffer.from(transaction.slice(2), "hex"));
+    const bytes = new Uint8Array(Buffer2.from(transaction.slice(2), "hex"));
     return {
       base64url: base64urlEncode(bytes),
       originalFormat: "hex"
@@ -136,7 +239,7 @@ function parseBitcoinTransaction(transaction) {
     };
   }
   if (typeof transaction === "string") {
-    const bytes = new Uint8Array(Buffer.from(transaction, "hex"));
+    const bytes = new Uint8Array(Buffer2.from(transaction, "hex"));
     return {
       base64url: base64urlEncode(bytes),
       originalFormat: "hex"
@@ -146,5 +249,7 @@ function parseBitcoinTransaction(transaction) {
 }
 export {
   parseMessage,
-  parseTransaction
+  parseSignMessageResponse,
+  parseTransaction,
+  parseTransactionResponse
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantom/parsers",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Transaction and message parsers for Phantom Wallet SDK",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -23,17 +23,29 @@
     "clean": "rm -rf dist",
     "test": "jest",
     "test:watch": "jest --watch",
+    "test:integration": "jest --testPathPattern=integration",
     "lint": "tsc --noEmit && eslint --cache . --ext .ts",
+    "check-types": "tsc --noEmit",
     "prettier": "prettier --write \"src/**/*.{ts}\""
   },
   "dependencies": {
     "@phantom/base64url": "^0.1.0",
-    "@phantom/client": "^0.1.3",
+    "@phantom/constants": "^0.0.2",
+    "bs58": "^6.0.0",
     "buffer": "^6.0.3"
   },
+  "optionalDependencies": {
+    "@mysten/sui.js": "^0.50.0",
+    "@solana/kit": "^2.1.1",
+    "@solana/web3.js": "^1.95.0",
+    "bitcoinjs-lib": "^6.1.0",
+    "ethers": "^6.0.0",
+    "viem": "^2.0.0"
+  },
   "devDependencies": {
     "@types/jest": "^29.5.12",
     "@types/node": "^20.11.0",
+    "dotenv": "^16.4.5",
     "eslint": "8.53.0",
     "jest": "^29.7.0",
     "prettier": "^3.5.2",