@profullstack/coinpay 0.4.6 → 0.4.8

package/bin/coinpay.js

@@ -216,6 +216,7 @@ ${colors.cyan}Commands:${colors.reset}
     refund <id>           Refund funds to depositor
     dispute <id>          Open a dispute
     events <id>           Get escrow audit log
+    auth <id>             Authenticate with escrow token
 
   ${colors.bright}webhook${colors.reset}
     logs <business-id>    Get webhook logs
@@ -226,11 +227,22 @@ ${colors.cyan}Wallet Options:${colors.reset}
   --chains <BTC,ETH,...>  Chains to derive (default: BTC,ETH,SOL,POL,BCH)
   --chain <chain>         Single chain for operations
   --to <address>          Recipient address
-  --amount <amount>       Amount to send
+  --amount <amount>       Amount to send (crypto)
+  --amount-fiat <amount>  Amount to send (fiat, requires --fiat)
+  --fiat <currency>       Fiat currency (USD, EUR, GBP, CAD, AUD, JPY, CHF, CNY, INR, BRL)
   --password <pass>       Wallet encryption password
   --wallet-file <path>    Custom wallet file (default: ~/.coinpay-wallet.gpg)
   --no-save               Don't save wallet locally after create/import
 
+${colors.cyan}Escrow Options:${colors.reset}
+  --chain <chain>         Blockchain (BTC, ETH, SOL, POL, BCH, etc.)
+  --amount <amount>       Crypto amount to escrow
+  --amount-fiat <amount>  Fiat amount to escrow (alternative to --amount)
+  --fiat <currency>       Fiat currency (required with --amount-fiat)
+  --depositor <address>   Depositor wallet address
+  --beneficiary <address> Beneficiary wallet address
+  --token <token>         Release or beneficiary token (for auth/release/refund)
+
 ${colors.cyan}Swap Options:${colors.reset}
   --from <coin>           Source coin (e.g., BTC)
   --to <coin>             Destination coin (e.g., ETH)
@@ -249,6 +261,18 @@ ${colors.cyan}Examples:${colors.reset}
 
   # Send transaction (auto-decrypts for signing)
   coinpay wallet send --chain ETH --to 0x123... --amount 0.1
+  
+  # Send transaction with fiat amount
+  coinpay wallet send --chain SOL --to abc123... --amount-fiat 10 --fiat USD
+
+  # Create escrow with crypto amount
+  coinpay escrow create --chain SOL --amount 0.5 --depositor abc... --beneficiary def...
+  
+  # Create escrow with fiat amount
+  coinpay escrow create --chain SOL --amount-fiat 50 --fiat USD --depositor abc... --beneficiary def...
+  
+  # Authenticate with escrow token
+  coinpay escrow auth escr_123 --token rel_abc456
 
   # Swap BTC to ETH
   coinpay swap quote --from BTC --to ETH --amount 0.1
@@ -1046,11 +1070,19 @@ async function handleWallet(subcommand, args, flags) {
       const chain = (flags.chain || '').toUpperCase();
       const to = flags.to;
       const amount = flags.amount;
+      const amountFiat = flags['amount-fiat'] ? parseFloat(flags['amount-fiat']) : undefined;
+      const fiatCurrency = flags.fiat;
       const priority = flags.priority || 'medium';
       
-      if (!chain || !to || !amount) {
-        print.error('Required: --chain, --to, --amount');
+      if (!chain || !to || (!amount && !amountFiat)) {
+        print.error('Required: --chain, --to, --amount (or --amount-fiat --fiat)');
         print.info('Usage: coinpay wallet send --chain ETH --to 0x123... --amount 0.1');
+        print.info('   or: coinpay wallet send --chain SOL --to abc123... --amount-fiat 10 --fiat USD');
+        return;
+      }
+
+      if (amountFiat && !fiatCurrency) {
+        print.error('--fiat is required when using --amount-fiat');
         return;
       }
       
@@ -1065,12 +1097,23 @@ async function handleWallet(subcommand, args, flags) {
       }
       
       try {
+        let finalAmount = amount;
+
+        // Convert fiat to crypto if needed
+        if (amountFiat && fiatCurrency) {
+          print.info(`Converting ${fiatCurrency} ${amountFiat.toFixed(2)} to ${chain}...`);
+          const apiClient = createClient();
+          const conversion = await apiClient.convertFiatToCrypto(amountFiat, fiatCurrency, chain);
+          finalAmount = conversion.cryptoAmount.toString();
+          print.success(`Converting ${fiatCurrency} ${amountFiat.toFixed(2)} → ${conversion.cryptoAmount.toFixed(6)} ${chain} (rate: 1 ${chain} = ${fiatCurrency} ${conversion.rate.toFixed(2)})`);
+        }
+
         const mnemonic = await getDecryptedMnemonic(flags);
         const wallet = await WalletClient.fromSeed(mnemonic, { baseUrl });
         
-        print.info(`Sending ${amount} ${chain} to ${to}...`);
+        print.info(`Sending ${finalAmount} ${chain} to ${to}...`);
         
-        const result = await wallet.send({ chain, to, amount, priority });
+        const result = await wallet.send({ chain, to, amount: finalAmount, priority });
         
         print.success('Transaction sent!');
         if (result.tx_hash) {
@@ -1369,20 +1412,36 @@ async function handleEscrow(subcommand, args, flags) {
   switch (subcommand) {
     case 'create': {
       const chain = flags.chain || flags.blockchain;
-      const amount = parseFloat(flags.amount);
+      const amount = flags.amount ? parseFloat(flags.amount) : undefined;
+      const amountFiat = flags['amount-fiat'] ? parseFloat(flags['amount-fiat']) : undefined;
+      const fiatCurrency = flags.fiat;
       const depositor = flags.depositor || flags['depositor-address'];
       const beneficiary = flags.beneficiary || flags['beneficiary-address'];
 
-      if (!chain || !amount || !depositor || !beneficiary) {
-        print.error('Required: --chain, --amount, --depositor, --beneficiary');
+      if (!chain || (!amount && !amountFiat) || !depositor || !beneficiary) {
+        print.error('Required: --chain, --amount (or --amount-fiat --fiat), --depositor, --beneficiary');
         process.exit(1);
       }
 
-      print.info(`Creating escrow: ${amount} ${chain}`);
+      if (amountFiat && !fiatCurrency) {
+        print.error('--fiat is required when using --amount-fiat');
+        process.exit(1);
+      }
+
+      // Show conversion if using fiat
+      let finalAmount = amount;
+      if (amountFiat && fiatCurrency) {
+        print.info(`Converting ${fiatCurrency} ${amountFiat.toFixed(2)} to ${chain}...`);
+        const conversion = await client.convertFiatToCrypto(amountFiat, fiatCurrency, chain);
+        finalAmount = conversion.cryptoAmount;
+        print.success(`Converting ${fiatCurrency} ${amountFiat.toFixed(2)} → ${finalAmount.toFixed(6)} ${chain} (rate: 1 ${chain} = ${fiatCurrency} ${conversion.rate.toFixed(2)})`);
+      }
+
+      print.info(`Creating escrow: ${finalAmount} ${chain}`);
 
       const escrow = await client.createEscrow({
         chain,
-        amount,
+        amount: finalAmount,
         depositorAddress: depositor,
         beneficiaryAddress: beneficiary,
         metadata: flags.metadata ? JSON.parse(flags.metadata) : undefined,
@@ -1393,7 +1452,9 @@ async function handleEscrow(subcommand, args, flags) {
       print.info(`  Deposit to: ${escrow.escrowAddress}`);
       print.info(`  Status: ${escrow.status}`);
       print.warn(`  Release Token: ${escrow.releaseToken}`);
+      print.warn(`  Beneficiary Token: ${escrow.beneficiaryToken}`);
       print.warn('  ⚠️  Save these tokens!');
+      print.info(`  Manage: coinpay escrow auth ${escrow.id} --token <token>`);
 
       if (flags.json) print.json(escrow);
       break;
@@ -1476,9 +1537,42 @@ async function handleEscrow(subcommand, args, flags) {
       break;
     }
 
+    case 'auth': {
+      const id = args[0];
+      const token = flags.token;
+      if (!id || !token) { 
+        print.error('Required: <id> --token <token>'); 
+        process.exit(1); 
+      }
+
+      const auth = await client.authenticateEscrow(id, token);
+      print.success(`Authenticated as: ${auth.role}`);
+      print.info(`Escrow Details:`);
+      print.info(`  ID: ${auth.escrow.id}`);
+      print.info(`  Status: ${auth.escrow.status}`);
+      print.info(`  Chain: ${auth.escrow.chain}`);
+      print.info(`  Amount: ${auth.escrow.amount}`);
+      print.info(`  Depositor: ${auth.escrow.depositorAddress}`);
+      print.info(`  Beneficiary: ${auth.escrow.beneficiaryAddress}`);
+      
+      // Show available actions based on role and status
+      if (auth.escrow.status === 'funded') {
+        if (auth.role === 'depositor') {
+          print.info(`Available actions: release, refund, dispute`);
+        } else if (auth.role === 'beneficiary') {
+          print.info(`Available actions: dispute`);
+        }
+      } else if (auth.escrow.status === 'pending') {
+        print.info(`Waiting for deposit to: ${auth.escrow.escrowAddress}`);
+      }
+
+      if (flags.json) print.json(auth);
+      break;
+    }
+
     default:
       print.error(`Unknown escrow command: ${subcommand}`);
-      print.info('Available: create, get, list, release, refund, dispute, events');
+      print.info('Available: create, get, list, release, refund, dispute, events, auth');
       process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/coinpay",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "CoinPay SDK & CLI — Accept cryptocurrency payments (BTC, ETH, SOL, POL, BCH, USDC) with wallet and swap support",
   "type": "module",
   "main": "./src/index.js",

package/src/client.js

@@ -306,6 +306,34 @@ export class CoinPayClient {
     return this.request(`/rates?crypto=${cryptocurrency}&fiat=${fiatCurrency}`);
   }
 
+  /**
+   * Convert fiat amount to cryptocurrency amount
+   * @param {number} fiatAmount - Fiat amount to convert
+   * @param {string} fiatCurrency - Fiat currency code (USD, EUR, etc.)
+   * @param {string} cryptoCurrency - Cryptocurrency code (BTC, ETH, SOL, etc.)
+   * @returns {Promise<Object>} { cryptoAmount, rate, fiat, crypto }
+   * 
+   * @example
+   * const result = await client.convertFiatToCrypto(50, 'USD', 'SOL');
+   * console.log(`$50 USD = ${result.cryptoAmount} SOL (rate: 1 SOL = $${result.rate})`);
+   */
+  async convertFiatToCrypto(fiatAmount, fiatCurrency, cryptoCurrency) {
+    const rateData = await this.request(`/rates?coin=${cryptoCurrency}&fiat=${fiatCurrency}`);
+    
+    if (!rateData.success || !rateData.rate) {
+      throw new Error(`Failed to get exchange rate for ${cryptoCurrency}/${fiatCurrency}`);
+    }
+
+    const cryptoAmount = fiatAmount / rateData.rate;
+    
+    return {
+      cryptoAmount: cryptoAmount,
+      rate: rateData.rate,
+      fiat: fiatCurrency,
+      crypto: cryptoCurrency
+    };
+  }
+
   /**
    * Get multiple exchange rates
    * @param {string[]} cryptocurrencies - Array of cryptocurrency codes
@@ -483,6 +511,17 @@ export class CoinPayClient {
     const { waitForEscrow } = await import('./escrow.js');
     return waitForEscrow(this, escrowId, options);
   }
+
+  /**
+   * Authenticate with escrow using token
+   * @param {string} escrowId - Escrow ID
+   * @param {string} token - Release token or beneficiary token
+   * @returns {Promise<Object>} { escrow, role }
+   */
+  async authenticateEscrow(escrowId, token) {
+    const { authenticateEscrow } = await import('./escrow.js');
+    return authenticateEscrow(this, escrowId, token);
+  }
 }
 
 export default CoinPayClient;

package/src/escrow.js

@@ -31,7 +31,9 @@
  * @param {CoinPayClient} client - API client instance
  * @param {Object} params - Escrow parameters
  * @param {string} params.chain - Blockchain (BTC, ETH, SOL, POL, etc.)
- * @param {number} params.amount - Crypto amount to escrow
+ * @param {number} [params.amount] - Crypto amount to escrow
+ * @param {number} [params.amountFiat] - Fiat amount to escrow (alternative to amount)
+ * @param {string} [params.fiatCurrency] - Fiat currency (required if amountFiat is used)
  * @param {string} params.depositorAddress - Wallet address for refunds
  * @param {string} params.beneficiaryAddress - Wallet address for releases
  * @param {string} [params.arbiterAddress] - Optional dispute resolver address
@@ -42,15 +44,33 @@
 export async function createEscrow(client, {
   chain,
   amount,
+  amountFiat,
+  fiatCurrency,
   depositorAddress,
   beneficiaryAddress,
   arbiterAddress,
   metadata,
   expiresInHours,
 }) {
+  let finalAmount = amount;
+  
+  // If fiat amount is provided, convert to crypto first
+  if (amountFiat && fiatCurrency) {
+    if (amount) {
+      throw new Error('Cannot specify both amount and amountFiat. Use one or the other.');
+    }
+    
+    const conversion = await client.convertFiatToCrypto(amountFiat, fiatCurrency, chain);
+    finalAmount = conversion.cryptoAmount;
+  } else if (amountFiat && !fiatCurrency) {
+    throw new Error('fiatCurrency is required when amountFiat is specified');
+  } else if (!amount && !amountFiat) {
+    throw new Error('Either amount or amountFiat must be specified');
+  }
+
   const body = {
     chain,
-    amount,
+    amount: finalAmount,
     depositor_address: depositorAddress,
     beneficiary_address: beneficiaryAddress,
   };
@@ -165,6 +185,30 @@ export async function disputeEscrow(client, escrowId, token, reason) {
   return normalizeEscrow(data);
 }
 
+/**
+ * Authenticate with escrow using token
+ * @param {CoinPayClient} client
+ * @param {string} escrowId - Escrow ID
+ * @param {string} token - Release token or beneficiary token
+ * @returns {Promise<Object>} { escrow, role } where role is 'depositor' or 'beneficiary'
+ * 
+ * @example
+ * const auth = await client.authenticateEscrow('escrow_123', 'rel_abc123');
+ * console.log(`Authenticated as: ${auth.role}`);
+ * console.log(`Escrow status: ${auth.escrow.status}`);
+ */
+export async function authenticateEscrow(client, escrowId, token) {
+  const data = await client.request(`/escrow/${escrowId}/auth`, {
+    method: 'POST',
+    body: JSON.stringify({ token }),
+  });
+  
+  return {
+    escrow: normalizeEscrow(data.escrow),
+    role: data.role,
+  };
+}
+
 /**
  * Get escrow event log
  * @param {CoinPayClient} client

package/src/index.js

@@ -63,6 +63,7 @@ import {
   disputeEscrow,
   getEscrowEvents,
   waitForEscrow,
+  authenticateEscrow,
 } from './escrow.js';
 
 // Wallet exports
@@ -106,6 +107,7 @@ export {
   disputeEscrow,
   getEscrowEvents,
   waitForEscrow,
+  authenticateEscrow,
   
   // Wallet
   WalletClient,

package/src/payments.js

@@ -169,6 +169,11 @@ export const FiatCurrency = {
   GBP: 'GBP',
   CAD: 'CAD',
   AUD: 'AUD',
+  JPY: 'JPY',
+  CHF: 'CHF',
+  CNY: 'CNY',
+  INR: 'INR',
+  BRL: 'BRL',
 };
 
 export default {

package/src/wallet.js

@@ -9,11 +9,11 @@
 import * as bip39 from '@scure/bip39';
 import { wordlist } from '@scure/bip39/wordlists/english';
 import { HDKey } from '@scure/bip32';
-import { secp256k1 } from '@noble/curves/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { sha256 } from '@noble/hashes/sha2.js';
-import { ripemd160 } from '@noble/hashes/ripemd160.js';
+import { ripemd160 } from '@noble/hashes/legacy.js';
 import { keccak_256 } from '@noble/hashes/sha3.js';
-import { ed25519 } from '@noble/curves/ed25519';
+import { ed25519 } from '@noble/curves/ed25519.js';
 import { hmac } from '@noble/hashes/hmac.js';
 import { sha512 } from '@noble/hashes/sha2.js';
 import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
@@ -218,8 +218,8 @@ function cashAddrPolymod(values) {
  */
 function deriveETHAddress(compressedPubKey) {
   // Decompress: get uncompressed point (65 bytes: 04 || x || y)
-  const point = secp256k1.ProjectivePoint.fromHex(compressedPubKey);
-  const uncompressed = point.toRawBytes(false); // 65 bytes with 04 prefix
+  const point = secp256k1.Point.fromBytes(compressedPubKey);
+  const uncompressed = point.toBytes(false); // 65 bytes with 04 prefix
   // Keccak256 of the 64 bytes (without 04 prefix)
   const hash = keccak_256(uncompressed.slice(1));
   // Last 20 bytes — EIP-55 checksummed