@coin-voyage/crypto 2.3.0 → 2.3.1-beta.0

package/dist/evm/use-evm-transaction.js

@@ -1,3 +1,4 @@
+import { getEvmPaymentData } from "@coin-voyage/shared/common";
 import { estimateFeesPerGas } from "viem/actions";
 import { useConfig, useSendTransaction, useWriteContract } from "wagmi";
 export function useEVMTransaction() {
@@ -5,14 +6,31 @@ export function useEVMTransaction() {
     const { sendTransactionAsync } = useSendTransaction();
     const config = useConfig();
     const execute = async (params) => {
-        const { chainId, toAddress, amount, token } = params;
-        const value = BigInt(amount);
-        const to = toAddress;
         const client = config.getClient();
         const gasEstimates = await estimateFeesPerGas(client, {
             chain: client.chain,
             type: "eip1559",
         });
+        const evmPaymentData = getEvmPaymentData(params.paymentData);
+        if (evmPaymentData) {
+            const tx = await sendTransactionAsync({
+                to: evmPaymentData.to,
+                data: evmPaymentData.data,
+                value: BigInt(evmPaymentData.value),
+                chainId: evmPaymentData.chainId,
+                maxFeePerGas: evmPaymentData.maxFeePerGas ? BigInt(evmPaymentData.maxFeePerGas) : gasEstimates.maxFeePerGas,
+                maxPriorityFeePerGas: evmPaymentData.maxPriorityFeePerGas
+                    ? BigInt(evmPaymentData.maxPriorityFeePerGas)
+                    : gasEstimates.maxPriorityFeePerGas,
+            });
+            return tx;
+        }
+        const { chainId, to: toAddress, amount, token } = params;
+        if (!toAddress || amount == undefined) {
+            throw new Error("Missing EVM transfer target or amount");
+        }
+        const value = BigInt(amount);
+        const to = toAddress;
         if (!token) {
             const tx = await sendTransactionAsync({
                 to,

package/dist/solana/use-solana-transaction.js

@@ -1,7 +1,10 @@
+import { getSolanaPaymentData } from "@coin-voyage/shared/common";
+import { hex } from "@scure/base";
 import { createTransferCheckedInstruction, getAssociatedTokenAddress } from "@solana/spl-token";
 import { useConnection, useWallet } from "@solana/wallet-adapter-react";
-import { ComputeBudgetProgram, PublicKey, SystemProgram, Transaction, TransactionInstruction, } from "@solana/web3.js";
+import { ComputeBudgetProgram, PublicKey, SystemProgram, Transaction, TransactionInstruction, VersionedTransaction, } from "@solana/web3.js";
 import { getOrCreateAssociatedTokenAccount } from "./get-or-create-ata";
+const INVALID_TX_PAYLOAD_ERROR = "Invalid Solana transaction payload: expected Transaction, VersionedTransaction, Uint8Array, byte array, hex, or base64";
 export function useSolanaTransaction() {
     const { connection } = useConnection();
     const wallet = useWallet();
@@ -14,10 +17,22 @@ export function useSolanaTransaction() {
                 throw new Error("Wallet not connected. Please reconnect your wallet and try again.");
             }
         }
-        const { fromAddress, toAddress, amount, token } = params;
+        const preparedPayment = getSolanaPaymentData(params.paymentData);
+        if (preparedPayment) {
+            const { context: { slot: minContextSlot }, value: { lastValidBlockHeight }, } = await connection.getLatestBlockhashAndContext();
+            const transaction = deserializePreparedSolanaTransaction(preparedPayment.transaction);
+            const signature = await wallet.sendTransaction(transaction, connection, {
+                minContextSlot,
+            });
+            return waitForTransactionConfirmation(signature, connection, lastValidBlockHeight);
+        }
+        const { from, to, amount, token } = params;
+        if (!to || amount == undefined) {
+            throw new Error("Missing Solana transfer target or amount");
+        }
         const transaction = new Transaction();
-        const senderPubKey = new PublicKey(fromAddress);
-        const receiverPubKey = new PublicKey(toAddress);
+        const senderPubKey = new PublicKey(from);
+        const receiverPubKey = new PublicKey(to);
         const instructions = [
             ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1000000 }),
         ];
@@ -56,6 +71,52 @@ export function useSolanaTransaction() {
     };
     return { execute };
 }
+function toSerializedTransactionBytes(value) {
+    if (value instanceof Uint8Array)
+        return value;
+    if (Array.isArray(value)) {
+        if (!value.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+            throw new Error("Invalid Solana transaction payload: array must contain byte values");
+        }
+        return Uint8Array.from(value);
+    }
+    if (typeof value !== "string") {
+        throw new Error(INVALID_TX_PAYLOAD_ERROR);
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error("Invalid Solana transaction payload: empty string");
+    }
+    const hexValue = normalized.startsWith("0x") ? normalized.slice(2) : normalized;
+    const looksLikeHex = hexValue.length > 0 && hexValue.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(hexValue);
+    if (looksLikeHex) {
+        return hex.decode(hexValue);
+    }
+    try {
+        return Uint8Array.from(atob(normalized), (char) => char.charCodeAt(0));
+    }
+    catch {
+        throw new Error(INVALID_TX_PAYLOAD_ERROR);
+    }
+}
+function deserializePreparedSolanaTransaction(serialized) {
+    if (serialized instanceof Transaction || serialized instanceof VersionedTransaction) {
+        return serialized;
+    }
+    const bytes = toSerializedTransactionBytes(serialized);
+    try {
+        return VersionedTransaction.deserialize(bytes);
+    }
+    catch {
+        // fall back to legacy Transaction
+    }
+    try {
+        return Transaction.from(bytes);
+    }
+    catch {
+        throw new Error(INVALID_TX_PAYLOAD_ERROR);
+    }
+}
 async function waitForTransactionConfirmation(signature, connection, lastValidBlockHeight) {
     const maxRetries = 30;
     const retryDelay = 2000;

package/dist/sui/use-sui-transaction.js

@@ -1,3 +1,4 @@
+import { getSuiPaymentData } from "@coin-voyage/shared/common";
 import { useReportTransactionEffects, useSignTransaction, useSuiClient } from "@mysten/dapp-kit";
 import { Transaction } from "@mysten/sui/transactions";
 import { SUI_PACKAGE_IDS } from "./constants";
@@ -6,25 +7,50 @@ export function useSUITransaction() {
     const { mutateAsync: signTransaction } = useSignTransaction();
     const { mutate: reportTransactionEffects } = useReportTransactionEffects();
     const execute = async (params) => {
-        const { fromAddress, toAddress, amount, token } = params;
+        const preparedPayment = getSuiPaymentData(params.paymentData);
+        if (preparedPayment) {
+            const transaction = typeof preparedPayment.transaction === "string"
+                ? preparedPayment.transaction
+                : Transaction.from(preparedPayment.transaction);
+            const { bytes, signature } = await signTransaction({
+                transaction,
+            });
+            const executeResult = await client.executeTransactionBlock({
+                transactionBlock: bytes,
+                signature,
+                options: {
+                    showRawEffects: true,
+                },
+            });
+            if (executeResult.rawEffects) {
+                reportTransactionEffects({
+                    effects: executeResult.rawEffects,
+                });
+            }
+            return executeResult.digest;
+        }
+        const { from: owner, to, amount, token } = params;
+        if (!to || amount == undefined) {
+            throw new Error("Missing Sui transfer target or amount");
+        }
         const tokenAddress = token?.address;
         const isNative = !tokenAddress || tokenAddress.toLowerCase() === SUI_PACKAGE_IDS["sui"].toLowerCase();
         const tx = new Transaction();
         const value = BigInt(amount);
         if (isNative) {
             const balance = await client.getBalance({
-                owner: fromAddress,
+                owner,
                 coinType: SUI_PACKAGE_IDS["sui"],
             });
             if (BigInt(balance.totalBalance) < value) {
                 throw new Error(`[CHECKOUT] Insufficient balance: ${balance}`);
             }
             const [coin] = tx.splitCoins(tx.gas, [value]);
-            tx.transferObjects([coin], toAddress);
+            tx.transferObjects([coin], to);
         }
         else {
             const coins = await client.getCoins({
-                owner: fromAddress,
+                owner,
                 coinType: tokenAddress,
             });
             let total = BigInt(0);
@@ -42,7 +68,7 @@ export function useSUITransaction() {
                 tx.mergeCoins(coinInput, coinInputs.slice(1));
             }
             const [paymentCoin] = tx.splitCoins(coinInput, [value]);
-            tx.transferObjects([paymentCoin], toAddress);
+            tx.transferObjects([paymentCoin], to);
         }
         const gasPrice = await client.getReferenceGasPrice();
         tx.setGasPrice(gasPrice);

package/dist/types/transaction.d.ts

@@ -1,10 +1,12 @@
+import type { CryptoPaymentData } from "@coin-voyage/shared/types";
 export type ExecuteTransaction = {
-    fromAddress: string;
-    toAddress: string;
-    amount: bigint;
+    from: string;
+    to?: string;
+    amount?: bigint;
     chainId?: number;
     token?: {
         address: string;
         decimals: number;
     };
+    paymentData?: CryptoPaymentData;
 };

package/dist/utxo/create-psbt-tx.js

@@ -40,9 +40,7 @@ export async function createPsbtTx(client, fromAddress, toAddress, amountSats) {
             txid: utxo.txId,
             index: utxo.vout,
             sequence: 0xfffffffd, // RBF
-            ...(addressType === AddressType.p2wpkh ||
-                addressType === AddressType.p2wsh ||
-                addressType === AddressType.p2tr
+            ...(addressType === AddressType.p2wpkh || addressType === AddressType.p2wsh || addressType === AddressType.p2tr
                 ? {
                     witnessUtxo: {
                         script: scripts.script,

package/dist/utxo/create-utxo-transport.js

@@ -1,10 +1,17 @@
-import { ankr, blockchair, blockcypher, fallback, http, mempool, } from "@bigmi/core";
+import { ankr, blockchair, blockcypher, fallback, http, mempool } from "@bigmi/core";
 import { ALCHEMY_KEY } from "../evm/utils";
 export function createUTXOTransport(rpcConfig) {
     const primaryRpc = rpcConfig
         ? http(rpcConfig.url, rpcConfig.config)
         : http(`https://bitcoin-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}`);
-    return fallback([primaryRpc, http(), blockchair(), blockcypher(), mempool(), ankr({
-            apiKey: "2a2801137db177be9c80522e690ec8b59ffc5260d030b2671b5e3936b917daac"
-        })]);
+    return fallback([
+        primaryRpc,
+        http(),
+        blockchair(),
+        blockcypher(),
+        mempool(),
+        ankr({
+            apiKey: "2a2801137db177be9c80522e690ec8b59ffc5260d030b2671b5e3936b917daac",
+        }),
+    ]);
 }

package/dist/utxo/use-utxo-transaction.js

@@ -1,12 +1,20 @@
 import { useAccount } from "@bigmi/react";
+import { getBitcoinPaymentData } from "@coin-voyage/shared/common";
 import { sendBtc } from "./send-btc";
 export function useUTXOTransaction() {
     const { account, connector } = useAccount();
     const execute = async (params) => {
-        const { toAddress, amount } = params;
+        const bitcoinPaymentData = getBitcoinPaymentData(params.paymentData);
+        if (bitcoinPaymentData) {
+            throw new Error("Prepared Bitcoin transactions are not supported in wallet flow yet.");
+        }
+        const { to: toAddress, amount } = params;
         if (!connector?.id || !account?.address) {
             throw new Error("No connection found");
         }
+        if (!toAddress || amount == undefined) {
+            throw new Error("Missing Bitcoin transfer target or amount");
+        }
         const txhash = await sendBtc({
             senderAddress: account.address,
             recipient: toAddress,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coin-voyage/crypto",
   "description": "Crypto utilities for Coin Voyage",
-  "version": "2.3.0",
+  "version": "2.3.1-beta.0",
   "private": false,
   "sideEffects": false,
   "author": "Lars <lars@coinvoyage.io>",
@@ -50,7 +50,7 @@
     "@solana/wallet-adapter-walletconnect": "0.1.21",
     "@solana/wallet-adapter-base": "0.9.27",
     "@solana/wallet-adapter-coinbase": "0.1.23",
-    "@coin-voyage/shared": "2.3.1"
+    "@coin-voyage/shared": "2.3.5-beta.3"
   },
   "devDependencies": {
     "@types/elliptic": "6.4.18"