@coin-voyage/crypto 2.2.3 → 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-default-utxo-config.d.ts

@@ -1,5 +1,5 @@
 import { type Config, CreateConnectorFn } from "@bigmi/client";
-import { HttpTransportConfig } from "@bigmi/core";
+import { type HttpTransportConfig } from "@bigmi/core";
 /**
  * UTXO Configuration for Wallets and Connectors
  * Includes options for Bigmi-specific configurations

package/dist/utxo/create-default-utxo-config.js

@@ -1,6 +1,6 @@
 import { createConfig, leather, magicEden, okx, onekey, phantom, unisat, xverse, } from "@bigmi/client";
-import { bitcoin, createClient, http } from "@bigmi/core";
-import { ALCHEMY_KEY } from "../evm/utils";
+import { bitcoin, createClient } from "@bigmi/core";
+import { createUTXOTransport } from "./create-utxo-transport";
 export function createDefaultBigmiConfig(props = {
     additionalConfigOptions: { multiInjectedProviderDiscovery: false },
 }) {
@@ -19,11 +19,10 @@ export function createDefaultBigmiConfig(props = {
         connectors,
         client({ chain }) {
             const chainRpcConfig = props?.rpcConfig;
-            let config = [http(), http(`https://bitcoin-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}`)];
-            if (chainRpcConfig) {
-                config = [http(chainRpcConfig.url, chainRpcConfig.config), http()];
-            }
-            return createClient({ chain, transport: config[0] });
+            return createClient({
+                chain,
+                transport: createUTXOTransport(chainRpcConfig),
+            });
         },
         ...props?.additionalConfigOptions,
     });

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

@@ -40,7 +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.p2wpkh || addressType === AddressType.p2wsh || addressType === AddressType.p2tr
                 ? {
                     witnessUtxo: {
                         script: scripts.script,

package/dist/utxo/create-utxo-transport.d.ts

@@ -0,0 +1,6 @@
+import { type HttpTransportConfig } from "@bigmi/core";
+export interface UTXORpcConfig {
+    url?: string | undefined;
+    config?: HttpTransportConfig;
+}
+export declare function createUTXOTransport(rpcConfig?: UTXORpcConfig): import("@bigmi/core").FallbackTransport<readonly [import("@bigmi/core").HttpTransport<undefined, false>, import("@bigmi/core").HttpTransport<import("@bigmi/core").RpcSchema, false>, import("@bigmi/core").HttpTransport<undefined, false>, import("@bigmi/core").HttpTransport<undefined, false>, import("@bigmi/core").HttpTransport<undefined, false>, import("@bigmi/core").HttpTransport<undefined, false>]>;

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

@@ -0,0 +1,17 @@
+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",
+        }),
+    ]);
+}

package/dist/utxo/send-btc.d.ts

@@ -1,4 +1,17 @@
+import { Account } from "@bigmi/core";
 import { UTXOConnectorId } from "../types/utxo-connector-id";
+type PhantomBitcoinProvider = {
+    isPhantom?: boolean;
+    requestAccounts(): Promise<Account[]>;
+    signPSBT(psbt: Uint8Array, options: {
+        inputsToSign: {
+            address: string;
+            signingIndexes: number[];
+            sigHash?: number;
+        }[];
+        finalize?: boolean;
+    }): Promise<Uint8Array>;
+};
 declare global {
     interface Window {
         LeatherProvider?: any;
@@ -8,7 +21,7 @@ declare global {
             bitcoin?: any;
         };
         phantom?: {
-            bitcoin?: any;
+            bitcoin?: PhantomBitcoinProvider;
         };
         xfi?: {
             bitcoin?: any;

package/dist/utxo/send-btc.js

@@ -1,5 +1,6 @@
 import { sendUTXOTransaction } from "@bigmi/core";
 import { ChainId } from "@coin-voyage/shared/types";
+import { hex } from "@scure/base";
 import { Psbt } from "bitcoinjs-lib";
 import { createUnsecuredToken } from "jsontokens";
 import { withTimeout } from "viem";
@@ -139,30 +140,22 @@ async function sendBtcPhantom(recipient) {
     }
     const publicClient = await getUTXOPublicClient(ChainId.BTC);
     const tx = await createPsbtTx(publicClient, paymentAccount, recipient.address, Number(recipient.amount));
-    const payAddress = paymentAccount.address;
-    const inputsToSign = new Map();
-    for (let i = 0; i < tx.inputsLength; i++) {
-        const input = tx.getInput(i);
-        if (inputsToSign.has(payAddress)) {
-            inputsToSign.get(payAddress).signingIndexes.push(input.index);
-        }
-        else {
-            inputsToSign.set(payAddress, {
-                address: payAddress,
-                sigHash: 0,
-                signingIndexes: [input.index],
-            });
-        }
-    }
+    const psbtBytes = tx.toPSBT();
+    const inputsToSign = [
+        {
+            address: paymentAccount.address,
+            signingIndexes: Array.from({ length: tx.inputsLength }, (_, index) => index),
+        },
+    ];
     try {
         // We give users 10 minutes to sign the transaction or it should be considered expired
-        const signedPsbtHex = await withTimeout(() => provider.signPSBT(tx.unsignedTx, {
-            inputsToSign: Array.from(inputsToSign.values()),
+        const signedPsbtBytes = await withTimeout(() => provider.signPSBT(psbtBytes, {
+            inputsToSign,
         }), {
             timeout: 600000,
             errorInstance: new Error("Transaction has expired."),
         });
-        const signedPsbt = Psbt.fromHex(signedPsbtHex).finalizeAllInputs();
+        const signedPsbt = Psbt.fromHex(hex.encode(signedPsbtBytes)).finalizeAllInputs();
         const txHex = signedPsbt.extractTransaction().toHex();
         // const signedTx = btc.Transaction.fromRaw(signedPSBTBytes)
         // signedTx.finalize()

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/dist/utxo/utxo-public-client.d.ts

@@ -1,7 +1,10 @@
-import { type UTXOSchema, Chain, Client, FallbackTransport, HttpTransport, PublicActions, WalletActions } from "@bigmi/core";
+import { type Client, type PublicActions, type UTXOSchema, type WalletActions, bitcoin } from "@bigmi/core";
+import { createUTXOTransport } from "./create-utxo-transport";
+type UTXOPublicClient = Client<ReturnType<typeof createUTXOTransport>, typeof bitcoin, undefined, UTXOSchema, PublicActions & WalletActions>;
 /**
  * Get an instance of a provider for a specific chain
  * @param chainId - Id of the chain the provider is for
  * @returns The public client for the given chain
  */
-export declare const getUTXOPublicClient: (chainId: number) => Promise<Client<FallbackTransport<readonly HttpTransport[]>, Chain, undefined, UTXOSchema, PublicActions & WalletActions>>;
+export declare const getUTXOPublicClient: (chainId: number) => Promise<UTXOPublicClient>;
+export {};

package/dist/utxo/utxo-public-client.js

@@ -1,5 +1,15 @@
-import { ankr, bitcoin, blockchair, blockcypher, createClient, fallback, mempool, publicActions, rpcSchema, walletActions, } from "@bigmi/core";
-// cached providers
+import { bitcoin, createClient, publicActions, rpcSchema, walletActions, } from "@bigmi/core";
+import { createUTXOTransport } from "./create-utxo-transport";
+function createUTXOPublicClient() {
+    return createClient({
+        chain: bitcoin,
+        rpcSchema: rpcSchema(),
+        transport: createUTXOTransport(),
+        pollingInterval: 10000,
+    })
+        .extend(publicActions)
+        .extend(walletActions);
+}
 const publicClients = {};
 /**
  * Get an instance of a provider for a specific chain
@@ -8,15 +18,7 @@ const publicClients = {};
  */
 export const getUTXOPublicClient = async (chainId) => {
     if (!publicClients[chainId]) {
-        const client = createClient({
-            chain: bitcoin,
-            rpcSchema: rpcSchema(),
-            transport: fallback([blockchair(), blockcypher(), mempool(), ankr()]),
-            pollingInterval: 10000,
-        })
-            .extend(publicActions)
-            .extend(walletActions);
-        publicClients[chainId] = client;
+        publicClients[chainId] = createUTXOPublicClient();
     }
     if (!publicClients[chainId]) {
         throw new Error(`Unable to configure provider for chain ${chainId}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coin-voyage/crypto",
   "description": "Crypto utilities for Coin Voyage",
-  "version": "2.2.3",
+  "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.2.5"
+    "@coin-voyage/shared": "2.3.5-beta.3"
   },
   "devDependencies": {
     "@types/elliptic": "6.4.18"