@phantom/parsers 1.0.0-beta.1 → 1.0.0-beta.12

package/README.md

@@ -1,6 +1,6 @@
 # @phantom/parsers
 
-A utility package for parsing and converting various message and transaction formats into base64url format for use with Phantom's API. This package provides a unified interface for handling different blockchain transaction formats and message types across multiple networks.
+A utility package for parsing and converting transaction formats into base64url format for use with Phantom's API. This package provides a unified interface for handling different blockchain transaction formats across multiple networks.
 
 ## Installation
 
@@ -12,10 +12,7 @@ yarn add @phantom/parsers
 
 ## Overview
 
-The parsers package provides two main functions:
-
-- **`parseMessage`** - Converts various message formats to base64url
-- **`parseTransactionToBase64Url`** - Converts various transaction formats to base64url for different blockchain networks
+- **`parseToKmsTransaction`** - Converts various transaction formats to base64url for different blockchain networks
 
 ## Supported Networks
 
@@ -26,40 +23,9 @@ The parsers package provides two main functions:
 
 ## API Reference
 
-### parseMessage(message)
-
-Converts various message formats to base64url encoding.
-
-**Parameters:**
-
-- `message` (string | Uint8Array | Buffer) - The message to parse
-
-**Returns:**
-
-- `ParsedMessage` object with:
-  - `base64url` (string) - Base64url encoded message
-  - `originalFormat` (string) - The detected input format
-
-**Example:**
-
-```typescript
-import { parseMessage } from "@phantom/parsers";
-
-// Plain text message
-const result1 = parseMessage("Hello, Phantom!");
-console.log(result1.base64url); // "SGVsbG8sIFBoYW50b20h"
-console.log(result1.originalFormat); // "string"
-
-// Uint8Array
-const bytes = new TextEncoder().encode("Hello, Phantom!");
-const result2 = parseMessage(bytes);
-console.log(result2.base64url); // "SGVsbG8sIFBoYW50b20h"
-console.log(result2.originalFormat); // "bytes"
-```
-
-### parseTransactionToBase64Url(transaction, networkId)
+### parseToKmsTransaction(transaction, networkId)
 
-Converts various transaction formats to base64url encoding based on the target network.
+Converts various transaction formats to different encoding based on the target network.
 
 **Parameters:**
 
@@ -78,25 +44,25 @@ Converts various transaction formats to base64url encoding based on the target n
 
 ```typescript
 import { Transaction } from "@solana/web3.js";
-import { parseTransactionToBase64Url } from "@phantom/parsers";
+import { parseToKmsTransaction } from "@phantom/parsers";
 import { NetworkId } from "@phantom/client";
 
 // Solana Web3.js Transaction
 const transaction = new Transaction().add(/* instructions */);
-const result = await parseTransactionToBase64Url(transaction, NetworkId.SOLANA_MAINNET);
+const result = await parseToKmsTransaction(transaction, NetworkId.SOLANA_MAINNET);
 
 // Raw bytes
 const rawBytes = new Uint8Array([1, 2, 3, 4]);
-const result2 = await parseTransactionToBase64Url(rawBytes, NetworkId.SOLANA_MAINNET);
+const result2 = await parseToKmsTransaction(rawBytes, NetworkId.SOLANA_MAINNET);
 
 // Hex string
-const result3 = await parseTransactionToBase64Url("0x01020304", NetworkId.SOLANA_MAINNET);
+const result3 = await parseToKmsTransaction("0x01020304", NetworkId.SOLANA_MAINNET);
 ```
 
 ### Ethereum/EVM
 
 ```typescript
-import { parseTransactionToBase64Url } from "@phantom/parsers";
+import { parseToKmsTransaction } from "@phantom/parsers";
 import { NetworkId } from "@phantom/client";
 
 // Viem/Ethers transaction object
@@ -108,45 +74,45 @@ const evmTransaction = {
   gasPrice: 20000000000n, // 20 gwei
 };
 
-const result = await parseTransactionToBase64Url(evmTransaction, NetworkId.ETHEREUM_MAINNET);
+const result = await parseToKmsTransaction(evmTransaction, NetworkId.ETHEREUM_MAINNET);
 
 // Raw transaction bytes
 const rawTx = new Uint8Array([
   /* transaction bytes */
 ]);
-const result2 = await parseTransactionToBase64Url(rawTx, NetworkId.ETHEREUM_MAINNET);
+const result2 = await parseToKmsTransaction(rawTx, NetworkId.ETHEREUM_MAINNET);
 
 // Hex-encoded transaction
-const result3 = await parseTransactionToBase64Url("0xf86c...", NetworkId.ETHEREUM_MAINNET);
+const result3 = await parseToKmsTransaction("0xf86c...", NetworkId.ETHEREUM_MAINNET);
 ```
 
 ### Bitcoin
 
 ```typescript
-import { parseTransactionToBase64Url } from "@phantom/parsers";
+import { parseToKmsTransaction } from "@phantom/parsers";
 import { NetworkId } from "@phantom/client";
 
 // Raw transaction bytes
 const bitcoinTx = new Uint8Array([
   /* bitcoin transaction bytes */
 ]);
-const result = await parseTransactionToBase64Url(bitcoinTx, NetworkId.BITCOIN_MAINNET);
+const result = await parseToKmsTransaction(bitcoinTx, NetworkId.BITCOIN_MAINNET);
 
 // Hex-encoded transaction
-const result2 = await parseTransactionToBase64Url("0x0100000001...", NetworkId.BITCOIN_MAINNET);
+const result2 = await parseToKmsTransaction("0x0100000001...", NetworkId.BITCOIN_MAINNET);
 ```
 
 ### Sui
 
 ```typescript
-import { parseTransactionToBase64Url } from "@phantom/parsers";
+import { parseToKmsTransaction } from "@phantom/parsers";
 import { NetworkId } from "@phantom/client";
 
 // Sui transaction bytes
 const suiTx = new Uint8Array([
   /* sui transaction bytes */
 ]);
-const result = await parseTransactionToBase64Url(suiTx, NetworkId.SUI_MAINNET);
+const result = await parseToKmsTransaction(suiTx, NetworkId.SUI_MAINNET);
 ```
 
 ## Format Detection
@@ -184,7 +150,7 @@ The parsers will throw descriptive errors for:
 
 ```typescript
 try {
-  const result = await parseTransactionToBase64Url(invalidData, "unsupported:network");
+  const result = await parseToKmsTransaction(invalidData, "unsupported:network");
 } catch (error) {
   console.error("Parsing failed:", error.message);
   // "Unsupported network: unsupported"

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { NetworkId } from '@phantom/constants';
-import { Transaction } from '@solana/transactions';
+import { Transaction as Transaction$1 } from '@solana/transactions';
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
 
 /**
  * Chain-specific transaction and message response parsing
@@ -22,25 +23,34 @@ interface ParsedTransactionResult {
 declare function parseSignMessageResponse(base64Response: string, networkId: NetworkId): ParsedSignatureResult;
 /**
  * Parse a transaction response from base64 rawTransaction to extract hash
+ * For Ethereum chains, converts base64url to hex format
  */
 declare function parseTransactionResponse(base64RawTransaction: string, networkId: NetworkId, hash?: string): ParsedTransactionResult;
+/**
+ * Parse Solana signed transaction from base64url encoded transaction bytes
+ * Supports both legacy Transaction and VersionedTransaction formats
+ */
+declare function parseSolanaSignedTransaction(base64RawTransaction: string): Transaction | VersionedTransaction | null;
+/**
+ * Deserialize Solana transaction from Uint8Array bytes
+ * Supports both legacy Transaction and VersionedTransaction formats
+ */
+declare function deserializeSolanaTransaction(transactionBytes: Uint8Array): Transaction | VersionedTransaction;
 
 interface ParsedTransaction {
-    base64url: string;
+    /** The parsed transaction string (base64url for Solana/Sui/Bitcoin, RLP-encoded hex for EVM) */
+    parsed?: string;
+    /** Original format of the input transaction */
     originalFormat: string;
 }
-interface ParsedMessage {
-    base64url: string;
-}
 
 /**
- * Parse a message to base64url format for the client
- */
-declare function parseMessage(message: string): ParsedMessage;
-/**
- * Parse a transaction to base64url format based on network type
+ * Parse a transaction to KMS format based on network type
+ * - Solana: base64url encoding
+ * - EVM chains: hex encoding
+ * - Sui, Bitcoin: base64url encoding
  */
-declare function parseTransactionToBase64Url(transaction: any, networkId: NetworkId): Promise<ParsedTransaction>;
-declare function parseSolanaKitTransactionToSolanaWeb3js(transaction: Transaction): any;
+declare function parseToKmsTransaction(transaction: any, networkId: NetworkId): Promise<ParsedTransaction>;
+declare function parseSolanaKitTransactionToSolanaWeb3js(transaction: Transaction$1): any;
 
-export { ParsedMessage, ParsedSignatureResult, ParsedTransaction, ParsedTransactionResult, parseMessage, parseSignMessageResponse, parseSolanaKitTransactionToSolanaWeb3js, parseTransactionResponse, parseTransactionToBase64Url };
+export { ParsedSignatureResult, ParsedTransaction, ParsedTransactionResult, deserializeSolanaTransaction, parseSignMessageResponse, parseSolanaKitTransactionToSolanaWeb3js, parseSolanaSignedTransaction, parseToKmsTransaction, parseTransactionResponse };

package/dist/index.js

@@ -30,22 +30,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  parseMessage: () => parseMessage,
+  deserializeSolanaTransaction: () => deserializeSolanaTransaction,
   parseSignMessageResponse: () => parseSignMessageResponse,
   parseSolanaKitTransactionToSolanaWeb3js: () => parseSolanaKitTransactionToSolanaWeb3js,
-  parseTransactionResponse: () => parseTransactionResponse,
-  parseTransactionToBase64Url: () => parseTransactionToBase64Url
+  parseSolanaSignedTransaction: () => parseSolanaSignedTransaction,
+  parseToKmsTransaction: () => parseToKmsTransaction,
+  parseTransactionResponse: () => parseTransactionResponse
 });
 module.exports = __toCommonJS(src_exports);
 var import_base64url2 = require("@phantom/base64url");
 var import_transactions = require("@solana/transactions");
 var import_buffer2 = require("buffer");
+var import_ethers = require("ethers");
 
 // src/response-parsers.ts
-var import_constants = require("@phantom/constants");
 var import_base64url = require("@phantom/base64url");
-var import_buffer = require("buffer");
+var import_constants = require("@phantom/constants");
+var import_utils = require("@phantom/utils");
+var import_web3 = require("@solana/web3.js");
 var import_bs58 = __toESM(require("bs58"));
+var import_buffer = require("buffer");
 function parseSignMessageResponse(base64Response, networkId) {
   const networkPrefix = networkId.split(":")[0].toLowerCase();
   switch (networkPrefix) {
@@ -67,15 +71,24 @@ function parseSignMessageResponse(base64Response, networkId) {
   }
 }
 function parseTransactionResponse(base64RawTransaction, networkId, hash) {
+  let rawTransaction = base64RawTransaction;
+  if ((0, import_utils.isEthereumChain)(networkId)) {
+    try {
+      const txBytes = (0, import_base64url.base64urlDecode)(base64RawTransaction);
+      rawTransaction = "0x" + import_buffer.Buffer.from(txBytes).toString("hex");
+    } catch (error) {
+      rawTransaction = base64RawTransaction.startsWith("0x") ? base64RawTransaction : "0x" + base64RawTransaction;
+    }
+  }
   if (hash) {
     return {
       hash,
-      rawTransaction: base64RawTransaction,
+      rawTransaction,
       blockExplorer: (0, import_constants.getExplorerUrl)(networkId, "transaction", hash)
     };
   } else {
     return {
-      rawTransaction: base64RawTransaction
+      rawTransaction
     };
   }
 }
@@ -95,21 +108,12 @@ function parseSolanaSignatureResponse(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
-    };
-  }
+  const signatureBytes = (0, import_base64url.base64urlDecode)(base64Response);
+  const signature = "0x" + import_buffer.Buffer.from(signatureBytes).toString("hex");
+  return {
+    signature,
+    rawSignature: base64Response
+  };
 }
 function parseSuiSignatureResponse(base64Response) {
   try {
@@ -141,14 +145,29 @@ function parseBitcoinSignatureResponse(base64Response) {
     };
   }
 }
+function parseSolanaSignedTransaction(base64RawTransaction) {
+  try {
+    const transactionBytes = (0, import_base64url.base64urlDecode)(base64RawTransaction);
+    return deserializeSolanaTransaction(transactionBytes);
+  } catch (error) {
+    return null;
+  }
+}
+function deserializeSolanaTransaction(transactionBytes) {
+  try {
+    const transaction = import_web3.Transaction.from(transactionBytes);
+    return transaction;
+  } catch (legacyError) {
+    if (legacyError instanceof Error && legacyError.message.includes("Versioned messages")) {
+      const versionedTransaction = import_web3.VersionedTransaction.deserialize(transactionBytes);
+      return versionedTransaction;
+    }
+    throw legacyError;
+  }
+}
 
 // src/index.ts
-function parseMessage(message) {
-  return {
-    base64url: (0, import_base64url2.stringToBase64url)(message)
-  };
-}
-async function parseTransactionToBase64Url(transaction, networkId) {
+async function parseToKmsTransaction(transaction, networkId) {
   const networkPrefix = networkId.split(":")[0].toLowerCase();
   switch (networkPrefix) {
     case "solana":
@@ -159,7 +178,7 @@ async function parseTransactionToBase64Url(transaction, networkId) {
     case "optimism":
     case "arbitrum":
     case "base":
-      return parseEVMTransactionToBase64Url(transaction);
+      return parseEVMTransactionToHex(transaction);
     case "sui":
       return await parseSuiTransactionToBase64Url(transaction);
     case "bitcoin":
@@ -171,7 +190,7 @@ async function parseTransactionToBase64Url(transaction, networkId) {
 function parseSolanaTransactionToBase64Url(transaction) {
   if (transaction?.messageBytes != null) {
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(transaction.messageBytes),
+      parsed: (0, import_base64url2.base64urlEncode)(transaction.messageBytes),
       originalFormat: "@solana/kit"
     };
   }
@@ -181,13 +200,13 @@ function parseSolanaTransactionToBase64Url(transaction) {
       verifySignatures: false
     });
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(serialized),
+      parsed: (0, import_base64url2.base64urlEncode)(serialized),
       originalFormat: "@solana/web3.js"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(transaction),
+      parsed: (0, import_base64url2.base64urlEncode)(transaction),
       originalFormat: "bytes"
     };
   }
@@ -195,7 +214,7 @@ function parseSolanaTransactionToBase64Url(transaction) {
     try {
       const bytes = import_buffer2.Buffer.from(transaction, "base64");
       return {
-        base64url: (0, import_base64url2.base64urlEncode)(new Uint8Array(bytes)),
+        parsed: (0, import_base64url2.base64urlEncode)(new Uint8Array(bytes)),
         originalFormat: "base64"
       };
     } catch {
@@ -204,50 +223,79 @@ function parseSolanaTransactionToBase64Url(transaction) {
   }
   throw new Error("Unsupported Solana transaction format");
 }
-function parseEVMTransactionToBase64Url(transaction) {
-  if (transaction && typeof transaction === "object" && (transaction.to || transaction.data)) {
-    const bytes = new TextEncoder().encode(
-      JSON.stringify(transaction, (_key, value) => typeof value === "bigint" ? value.toString() : value)
-    );
+function parseEVMTransactionToHex(transaction) {
+  if (typeof transaction === "string" && transaction.startsWith("0x")) {
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(bytes),
-      originalFormat: "viem"
+      parsed: transaction,
+      originalFormat: "hex"
     };
   }
   if (transaction?.serialize && typeof transaction.serialize === "function") {
     const serialized = transaction.serialize();
-    const bytes = new Uint8Array(import_buffer2.Buffer.from(serialized.slice(2), "hex"));
+    const hex = serialized.startsWith("0x") ? serialized : "0x" + serialized;
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(bytes),
+      parsed: hex,
       originalFormat: "ethers"
     };
   }
   if (transaction instanceof Uint8Array) {
+    const hex = "0x" + import_buffer2.Buffer.from(transaction).toString("hex");
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(transaction),
+      parsed: hex,
       originalFormat: "bytes"
     };
   }
-  if (typeof transaction === "string" && transaction.startsWith("0x")) {
-    const bytes = new Uint8Array(import_buffer2.Buffer.from(transaction.slice(2), "hex"));
-    return {
-      base64url: (0, import_base64url2.base64urlEncode)(bytes),
-      originalFormat: "hex"
-    };
+  if (transaction && typeof transaction === "object" && (transaction.to || transaction.data || transaction.from)) {
+    try {
+      const { from, gas, ...txForSerialization } = transaction;
+      if (gas) {
+        txForSerialization.gasLimit = gas;
+      }
+      if (!txForSerialization.gasLimit) {
+        if (txForSerialization.to && txForSerialization.value && !txForSerialization.data) {
+          txForSerialization.gasLimit = "0x5208";
+        }
+      }
+      if (txForSerialization.to && typeof txForSerialization.to === "string") {
+        try {
+          txForSerialization.to = (0, import_ethers.getAddress)(txForSerialization.to);
+        } catch {
+          txForSerialization.to = txForSerialization.to.toLowerCase();
+        }
+      }
+      const serialized = import_ethers.Transaction.from(txForSerialization).unsignedSerialized;
+      const hex = serialized.startsWith("0x") ? serialized : "0x" + serialized;
+      return {
+        parsed: hex,
+        originalFormat: "json"
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      const txKeys = transaction ? Object.keys(transaction).join(", ") : "N/A";
+      const txValues = transaction ? JSON.stringify(transaction, null, 2) : "N/A";
+      throw new Error(
+        `Failed to RLP encode EVM transaction: ${errorMessage}.
+Transaction keys: [${txKeys}].
+Transaction: ${txValues}
+Please ensure the transaction object includes required fields (to, value, chainId, gasLimit or gasPrice, etc.)`
+      );
+    }
   }
-  throw new Error("Unsupported EVM transaction format");
+  throw new Error(
+    "Unsupported EVM transaction format. Expected hex string, bytes, or transaction object with 'to', 'data', or 'from' fields."
+  );
 }
 async function parseSuiTransactionToBase64Url(transaction) {
   if (transaction?.serialize && typeof transaction.serialize === "function") {
     const serialized = transaction.serialize();
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(serialized),
+      parsed: (0, import_base64url2.base64urlEncode)(serialized),
       originalFormat: "sui-sdk"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(transaction),
+      parsed: (0, import_base64url2.base64urlEncode)(transaction),
       originalFormat: "bytes"
     };
   }
@@ -256,7 +304,7 @@ async function parseSuiTransactionToBase64Url(transaction) {
     if (built?.serialize && typeof built.serialize === "function") {
       const serialized = built.serialize();
       return {
-        base64url: (0, import_base64url2.base64urlEncode)(serialized),
+        parsed: (0, import_base64url2.base64urlEncode)(serialized),
         originalFormat: "transaction-block"
       };
     }
@@ -267,20 +315,20 @@ function parseBitcoinTransactionToBase64Url(transaction) {
   if (transaction?.toBuffer && typeof transaction.toBuffer === "function") {
     const buffer = transaction.toBuffer();
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(new Uint8Array(buffer)),
+      parsed: (0, import_base64url2.base64urlEncode)(new Uint8Array(buffer)),
       originalFormat: "bitcoinjs-lib"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(transaction),
+      parsed: (0, import_base64url2.base64urlEncode)(transaction),
       originalFormat: "bytes"
     };
   }
   if (typeof transaction === "string") {
     const bytes = new Uint8Array(import_buffer2.Buffer.from(transaction, "hex"));
     return {
-      base64url: (0, import_base64url2.base64urlEncode)(bytes),
+      parsed: (0, import_base64url2.base64urlEncode)(bytes),
       originalFormat: "hex"
     };
   }
@@ -297,9 +345,10 @@ function parseSolanaKitTransactionToSolanaWeb3js(transaction) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  parseMessage,
+  deserializeSolanaTransaction,
   parseSignMessageResponse,
   parseSolanaKitTransactionToSolanaWeb3js,
-  parseTransactionResponse,
-  parseTransactionToBase64Url
+  parseSolanaSignedTransaction,
+  parseToKmsTransaction,
+  parseTransactionResponse
 });

package/dist/index.mjs

@@ -1,13 +1,16 @@
 // src/index.ts
-import { base64urlEncode, stringToBase64url } from "@phantom/base64url";
+import { base64urlEncode } from "@phantom/base64url";
 import { getTransactionEncoder } from "@solana/transactions";
 import { Buffer as Buffer2 } from "buffer";
+import { Transaction as EthersTransaction, getAddress } from "ethers";
 
 // src/response-parsers.ts
-import { getExplorerUrl } from "@phantom/constants";
 import { base64urlDecode } from "@phantom/base64url";
-import { Buffer } from "buffer";
+import { getExplorerUrl } from "@phantom/constants";
+import { isEthereumChain } from "@phantom/utils";
+import { Transaction, VersionedTransaction } from "@solana/web3.js";
 import bs58 from "bs58";
+import { Buffer } from "buffer";
 function parseSignMessageResponse(base64Response, networkId) {
   const networkPrefix = networkId.split(":")[0].toLowerCase();
   switch (networkPrefix) {
@@ -29,15 +32,24 @@ function parseSignMessageResponse(base64Response, networkId) {
   }
 }
 function parseTransactionResponse(base64RawTransaction, networkId, hash) {
+  let rawTransaction = base64RawTransaction;
+  if (isEthereumChain(networkId)) {
+    try {
+      const txBytes = base64urlDecode(base64RawTransaction);
+      rawTransaction = "0x" + Buffer.from(txBytes).toString("hex");
+    } catch (error) {
+      rawTransaction = base64RawTransaction.startsWith("0x") ? base64RawTransaction : "0x" + base64RawTransaction;
+    }
+  }
   if (hash) {
     return {
       hash,
-      rawTransaction: base64RawTransaction,
+      rawTransaction,
       blockExplorer: getExplorerUrl(networkId, "transaction", hash)
     };
   } else {
     return {
-      rawTransaction: base64RawTransaction
+      rawTransaction
     };
   }
 }
@@ -57,21 +69,12 @@ function parseSolanaSignatureResponse(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
-    };
-  }
+  const signatureBytes = base64urlDecode(base64Response);
+  const signature = "0x" + Buffer.from(signatureBytes).toString("hex");
+  return {
+    signature,
+    rawSignature: base64Response
+  };
 }
 function parseSuiSignatureResponse(base64Response) {
   try {
@@ -103,14 +106,29 @@ function parseBitcoinSignatureResponse(base64Response) {
     };
   }
 }
+function parseSolanaSignedTransaction(base64RawTransaction) {
+  try {
+    const transactionBytes = base64urlDecode(base64RawTransaction);
+    return deserializeSolanaTransaction(transactionBytes);
+  } catch (error) {
+    return null;
+  }
+}
+function deserializeSolanaTransaction(transactionBytes) {
+  try {
+    const transaction = Transaction.from(transactionBytes);
+    return transaction;
+  } catch (legacyError) {
+    if (legacyError instanceof Error && legacyError.message.includes("Versioned messages")) {
+      const versionedTransaction = VersionedTransaction.deserialize(transactionBytes);
+      return versionedTransaction;
+    }
+    throw legacyError;
+  }
+}
 
 // src/index.ts
-function parseMessage(message) {
-  return {
-    base64url: stringToBase64url(message)
-  };
-}
-async function parseTransactionToBase64Url(transaction, networkId) {
+async function parseToKmsTransaction(transaction, networkId) {
   const networkPrefix = networkId.split(":")[0].toLowerCase();
   switch (networkPrefix) {
     case "solana":
@@ -121,7 +139,7 @@ async function parseTransactionToBase64Url(transaction, networkId) {
     case "optimism":
     case "arbitrum":
     case "base":
-      return parseEVMTransactionToBase64Url(transaction);
+      return parseEVMTransactionToHex(transaction);
     case "sui":
       return await parseSuiTransactionToBase64Url(transaction);
     case "bitcoin":
@@ -133,7 +151,7 @@ async function parseTransactionToBase64Url(transaction, networkId) {
 function parseSolanaTransactionToBase64Url(transaction) {
   if (transaction?.messageBytes != null) {
     return {
-      base64url: base64urlEncode(transaction.messageBytes),
+      parsed: base64urlEncode(transaction.messageBytes),
       originalFormat: "@solana/kit"
     };
   }
@@ -143,13 +161,13 @@ function parseSolanaTransactionToBase64Url(transaction) {
       verifySignatures: false
     });
     return {
-      base64url: base64urlEncode(serialized),
+      parsed: base64urlEncode(serialized),
       originalFormat: "@solana/web3.js"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: base64urlEncode(transaction),
+      parsed: base64urlEncode(transaction),
       originalFormat: "bytes"
     };
   }
@@ -157,7 +175,7 @@ function parseSolanaTransactionToBase64Url(transaction) {
     try {
       const bytes = Buffer2.from(transaction, "base64");
       return {
-        base64url: base64urlEncode(new Uint8Array(bytes)),
+        parsed: base64urlEncode(new Uint8Array(bytes)),
         originalFormat: "base64"
       };
     } catch {
@@ -166,50 +184,79 @@ function parseSolanaTransactionToBase64Url(transaction) {
   }
   throw new Error("Unsupported Solana transaction format");
 }
-function parseEVMTransactionToBase64Url(transaction) {
-  if (transaction && typeof transaction === "object" && (transaction.to || transaction.data)) {
-    const bytes = new TextEncoder().encode(
-      JSON.stringify(transaction, (_key, value) => typeof value === "bigint" ? value.toString() : value)
-    );
+function parseEVMTransactionToHex(transaction) {
+  if (typeof transaction === "string" && transaction.startsWith("0x")) {
     return {
-      base64url: base64urlEncode(bytes),
-      originalFormat: "viem"
+      parsed: transaction,
+      originalFormat: "hex"
     };
   }
   if (transaction?.serialize && typeof transaction.serialize === "function") {
     const serialized = transaction.serialize();
-    const bytes = new Uint8Array(Buffer2.from(serialized.slice(2), "hex"));
+    const hex = serialized.startsWith("0x") ? serialized : "0x" + serialized;
     return {
-      base64url: base64urlEncode(bytes),
+      parsed: hex,
       originalFormat: "ethers"
     };
   }
   if (transaction instanceof Uint8Array) {
+    const hex = "0x" + Buffer2.from(transaction).toString("hex");
     return {
-      base64url: base64urlEncode(transaction),
+      parsed: hex,
       originalFormat: "bytes"
     };
   }
-  if (typeof transaction === "string" && transaction.startsWith("0x")) {
-    const bytes = new Uint8Array(Buffer2.from(transaction.slice(2), "hex"));
-    return {
-      base64url: base64urlEncode(bytes),
-      originalFormat: "hex"
-    };
+  if (transaction && typeof transaction === "object" && (transaction.to || transaction.data || transaction.from)) {
+    try {
+      const { from, gas, ...txForSerialization } = transaction;
+      if (gas) {
+        txForSerialization.gasLimit = gas;
+      }
+      if (!txForSerialization.gasLimit) {
+        if (txForSerialization.to && txForSerialization.value && !txForSerialization.data) {
+          txForSerialization.gasLimit = "0x5208";
+        }
+      }
+      if (txForSerialization.to && typeof txForSerialization.to === "string") {
+        try {
+          txForSerialization.to = getAddress(txForSerialization.to);
+        } catch {
+          txForSerialization.to = txForSerialization.to.toLowerCase();
+        }
+      }
+      const serialized = EthersTransaction.from(txForSerialization).unsignedSerialized;
+      const hex = serialized.startsWith("0x") ? serialized : "0x" + serialized;
+      return {
+        parsed: hex,
+        originalFormat: "json"
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      const txKeys = transaction ? Object.keys(transaction).join(", ") : "N/A";
+      const txValues = transaction ? JSON.stringify(transaction, null, 2) : "N/A";
+      throw new Error(
+        `Failed to RLP encode EVM transaction: ${errorMessage}.
+Transaction keys: [${txKeys}].
+Transaction: ${txValues}
+Please ensure the transaction object includes required fields (to, value, chainId, gasLimit or gasPrice, etc.)`
+      );
+    }
   }
-  throw new Error("Unsupported EVM transaction format");
+  throw new Error(
+    "Unsupported EVM transaction format. Expected hex string, bytes, or transaction object with 'to', 'data', or 'from' fields."
+  );
 }
 async function parseSuiTransactionToBase64Url(transaction) {
   if (transaction?.serialize && typeof transaction.serialize === "function") {
     const serialized = transaction.serialize();
     return {
-      base64url: base64urlEncode(serialized),
+      parsed: base64urlEncode(serialized),
       originalFormat: "sui-sdk"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: base64urlEncode(transaction),
+      parsed: base64urlEncode(transaction),
       originalFormat: "bytes"
     };
   }
@@ -218,7 +265,7 @@ async function parseSuiTransactionToBase64Url(transaction) {
     if (built?.serialize && typeof built.serialize === "function") {
       const serialized = built.serialize();
       return {
-        base64url: base64urlEncode(serialized),
+        parsed: base64urlEncode(serialized),
         originalFormat: "transaction-block"
       };
     }
@@ -229,20 +276,20 @@ function parseBitcoinTransactionToBase64Url(transaction) {
   if (transaction?.toBuffer && typeof transaction.toBuffer === "function") {
     const buffer = transaction.toBuffer();
     return {
-      base64url: base64urlEncode(new Uint8Array(buffer)),
+      parsed: base64urlEncode(new Uint8Array(buffer)),
       originalFormat: "bitcoinjs-lib"
     };
   }
   if (transaction instanceof Uint8Array) {
     return {
-      base64url: base64urlEncode(transaction),
+      parsed: base64urlEncode(transaction),
       originalFormat: "bytes"
     };
   }
   if (typeof transaction === "string") {
     const bytes = new Uint8Array(Buffer2.from(transaction, "hex"));
     return {
-      base64url: base64urlEncode(bytes),
+      parsed: base64urlEncode(bytes),
       originalFormat: "hex"
     };
   }
@@ -258,9 +305,10 @@ function parseSolanaKitTransactionToSolanaWeb3js(transaction) {
   return fakeVersioned;
 }
 export {
-  parseMessage,
+  deserializeSolanaTransaction,
   parseSignMessageResponse,
   parseSolanaKitTransactionToSolanaWeb3js,
-  parseTransactionResponse,
-  parseTransactionToBase64Url
+  parseSolanaSignedTransaction,
+  parseToKmsTransaction,
+  parseTransactionResponse
 };

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@phantom/parsers",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.12",
   "description": "Transaction and message parsers for Phantom Wallet SDK",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phantom/phantom-connect-sdk",
+    "directory": "packages/parsers"
+  },
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -29,21 +34,24 @@
     "prettier": "prettier --write \"src/**/*.{ts}\""
   },
   "dependencies": {
-    "@phantom/base64url": "^1.0.0-beta.1",
-    "@phantom/constants": "^1.0.0-beta.1",
-    "@solana/kit": "^2.1.1",
+    "@phantom/base64url": "^1.0.0-beta.12",
+    "@phantom/constants": "^1.0.0-beta.12",
+    "@phantom/sdk-types": "^1.0.0-beta.12",
+    "@phantom/utils": "^1.0.0-beta.24",
     "@solana/transactions": "^2.0.0",
+    "@solana/web3.js": "^1.95.0",
     "bs58": "^6.0.0",
-    "buffer": "^6.0.3"
+    "buffer": "^6.0.3",
+    "ethers": "^6.0.0"
   },
   "optionalDependencies": {
     "@mysten/sui.js": "^0.50.0",
-    "@solana/web3.js": "^1.95.0",
     "bitcoinjs-lib": "^6.1.0",
-    "ethers": "^6.0.0",
     "viem": "^2.0.0"
   },
   "devDependencies": {
+    "@solana/kit": "^2.1.1",
+    "@solana/web3.js": "^1.95.0",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.11.0",
     "dotenv": "^16.4.5",