xyqon 0.3.0 → 0.4.1

package/README.md

@@ -67,7 +67,8 @@ xyqon send \
 ```
 
 The transaction is broadcast to reachable public nodes. A miner must include it in a block before the receiver sees the confirmed balance.
-The client checks the best reachable public chain before broadcasting and refuses sends that exceed the wallet's confirmed XYQON balance.
+The client checks the best reachable public chain before broadcasting, refuses sends that exceed the wallet's confirmed XYQON balance, and now requires at least one node to verify the transaction as pending or confirmed before returning success.
+If every reachable node rejects the transaction or cannot return a transaction status, the send fails with the node's rejection reason when available.
 
 ## Create And Send Coins
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xyqon",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Friendly wallet CLI and JavaScript client for the XYQON network.",
   "keywords": [
     "xyqon",

package/src/cli.js

@@ -42,7 +42,7 @@ ${color('bold', 'Usage')}
   xyqon wallet new --name <NAME> [--out <FILE>]
   xyqon wallet show [--wallet <FILE>] [--private]
   xyqon balance [--wallet <FILE>] [--address <PUBLIC_KEY>]
-  xyqon send --to <PUBLIC_KEY> --amount <AMOUNT> [--wallet <FILE>]
+  xyqon send --to <PUBLIC_KEY> --amount <AMOUNT> [--fee <AMOUNT>] [--wallet <FILE>]
   xyqon coin create --symbol <SYMBOL> --name <NAME> --supply <AMOUNT> [--wallet <FILE>]
   xyqon coin send --symbol <SYMBOL> --to <PUBLIC_KEY> --amount <AMOUNT> [--wallet <FILE>]
   xyqon nft mint --collection <SYMBOL> --token-id <ID> --name <NAME> [--image-url <URL>] [--wallet <FILE>]
@@ -58,6 +58,16 @@ ${color('bold', 'Defaults')}
 `);
 }
 
+function printDelivery(result, label = 'Delivered') {
+  console.log(`${color('green', `${label}:`)} ${result.verifiedBy}/${result.peers.length} nodes verified pending or confirmed`);
+  if (result.rejectedBy > 0) {
+    console.log(`${color('red', 'Rejected:')} ${result.rejectedBy}/${result.peers.length} nodes`);
+  }
+  if (result.unverifiedBy > 0) {
+    console.log(`${color('yellow', 'Unverified:')} ${result.unverifiedBy}/${result.peers.length} nodes did not return a transaction status`);
+  }
+}
+
 function parseArgs(argv) {
   const values = { _: [] };
   for (let index = 0; index < argv.length; index += 1) {
@@ -152,15 +162,17 @@ async function run() {
       wallet,
       recipient: options.to,
       amount: options.amount,
+      fee: options.fee,
       peers: peersFromOptions(options)
     });
 
     printHero('Transaction Sent');
     console.log(`${color('bold', 'Amount:')} ${result.transaction.amount} XYQON`);
+    console.log(`${color('bold', 'Fee:')} ${result.transaction.fee} XYQON`);
     console.log(`${color('bold', 'To:')} ${result.transaction.recipient}`);
     console.log(`${color('bold', 'Transaction ID:')} ${result.transactionId}`);
     console.log(`${color('dim', 'Checked balance:')} ${result.preflight.balance} XYQON at block ${result.preflight.blockHeight}`);
-    console.log(`${color('green', 'Delivered:')} ${result.acceptedBy}/${result.peers.length} reachable nodes`);
+    printDelivery(result);
     console.log(color('yellow', 'The receiver balance updates after a miner includes this transaction in a block.'));
     return;
   }
@@ -189,7 +201,7 @@ async function run() {
     console.log(`${color('bold', 'Symbol:')} ${result.transaction.asset_operation.CreateCoin.symbol}`);
     console.log(`${color('bold', 'Supply:')} ${result.transaction.asset_operation.CreateCoin.supply}`);
     console.log(`${color('bold', 'Transaction ID:')} ${result.transactionId}`);
-    console.log(`${color('green', 'Broadcast:')} ${result.acceptedBy}/${result.peers.length} reachable nodes`);
+    printDelivery(result, 'Broadcast');
     console.log(color('yellow', 'The coin exists after a miner includes this transaction in a block.'));
     return;
   }
@@ -219,7 +231,7 @@ async function run() {
     console.log(`${color('bold', 'To:')} ${result.transaction.recipient}`);
     console.log(`${color('bold', 'Transaction ID:')} ${result.transactionId}`);
     console.log(`${color('dim', 'Checked balance:')} ${result.preflight.balance} ${result.preflight.symbol} at block ${result.preflight.blockHeight}`);
-    console.log(`${color('green', 'Delivered:')} ${result.acceptedBy}/${result.peers.length} reachable nodes`);
+    printDelivery(result);
     return;
   }
 
@@ -247,7 +259,7 @@ async function run() {
     printHero('NFT Minted');
     console.log(`${color('bold', 'NFT:')} ${result.transaction.asset_operation.MintNft.collection}:${result.transaction.asset_operation.MintNft.token_id}`);
     console.log(`${color('bold', 'Transaction ID:')} ${result.transactionId}`);
-    console.log(`${color('green', 'Broadcast:')} ${result.acceptedBy}/${result.peers.length} reachable nodes`);
+    printDelivery(result, 'Broadcast');
     console.log(color('yellow', 'The NFT exists after a miner includes this transaction in a block.'));
     return;
   }
@@ -276,7 +288,7 @@ async function run() {
     console.log(`${color('bold', 'NFT:')} ${result.transaction.asset_operation.TransferNft.collection}:${result.transaction.asset_operation.TransferNft.token_id}`);
     console.log(`${color('bold', 'To:')} ${result.transaction.recipient}`);
     console.log(`${color('bold', 'Transaction ID:')} ${result.transactionId}`);
-    console.log(`${color('green', 'Broadcast:')} ${result.acceptedBy}/${result.peers.length} reachable nodes`);
+    printDelivery(result, 'Broadcast');
     return;
   }
 

package/src/index.js

@@ -9,6 +9,7 @@ export const DEFAULT_PEERS = [
   '147.182.138.183:7101'
 ];
 const XYQON_EPSILON = 0.00000001;
+export const DEFAULT_XYQON_TRANSACTION_FEE = 0.001;
 
 export const DEFAULT_WALLET_PATH = 'xyqon.wallet.json';
 
@@ -103,8 +104,11 @@ function stringifyAssetOperationForSigning(assetOperation) {
   throw new Error('unknown asset operation');
 }
 
-export function transactionPayload(sender, recipient, amount, senderPublicKey, assetOperation = null) {
-  const base = `${sender}|${recipient}|${Number(amount).toFixed(8)}|${senderPublicKey}`;
+export function transactionPayload(sender, recipient, amount, senderPublicKey, assetOperation = null, fee = 0) {
+  let base = `${sender}|${recipient}|${Number(amount).toFixed(8)}|${senderPublicKey}`;
+  if (Math.abs(Number(fee)) > XYQON_EPSILON) {
+    base = `${base}|fee:${Number(fee).toFixed(8)}`;
+  }
   const serializedAsset = stringifyAssetOperationForSigning(assetOperation);
   return serializedAsset ? `${base}|${serializedAsset}` : base;
 }
@@ -174,22 +178,27 @@ export function normalizeTokenAmount(amount, label = 'amount') {
   return numeric;
 }
 
-export function createSignedTransaction(wallet, recipient, amount) {
+export function createSignedTransaction(wallet, recipient, amount, fee = DEFAULT_XYQON_TRANSACTION_FEE) {
   const numericAmount = Number(amount);
   if (!Number.isFinite(numericAmount) || numericAmount <= 0) {
     throw new Error('amount must be a positive number');
   }
+  const numericFee = Number(fee);
+  if (!Number.isFinite(numericFee) || numericFee < 0) {
+    throw new Error('fee must be a non-negative number');
+  }
 
   const privateKey = hexToBytes(wallet.private_key);
   const senderPublicKey = assertWalletMatchesPrivateKey(wallet, privateKey);
 
-  const payload = transactionPayload(wallet.name, recipient, numericAmount, senderPublicKey);
+  const payload = transactionPayload(wallet.name, recipient, numericAmount, senderPublicKey, null, numericFee);
   const signature = ed25519.sign(new TextEncoder().encode(payload), privateKey);
 
   return {
     sender: wallet.name,
     recipient,
     amount: numericAmount,
+    fee: numericFee,
     sender_public_key: senderPublicKey,
     signature: bytesToHex(signature)
   };
@@ -325,6 +334,62 @@ export function sendNetworkMessage(peer, message, timeoutMs = 5000) {
   });
 }
 
+export function sendTransactionMessage(peer, transaction, timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    const normalizedPeer = normalizePeer(peer);
+    const [host, portText] = normalizedPeer.split(':');
+    const socket = net.createConnection({ host, port: Number(portText) });
+    const startedAt = Date.now();
+    const id = transactionId(transaction);
+    let data = '';
+    let wrote = false;
+    let settled = false;
+
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.destroy();
+      resolve({ peer: normalizedPeer, latencyMs: Date.now() - startedAt, ...result });
+    };
+
+    socket.setTimeout(timeoutMs);
+    socket.on('connect', () => {
+      socket.write(`${JSON.stringify({ NewTransaction: transaction })}\n`, () => {
+        wrote = true;
+      });
+    });
+    socket.on('data', (chunk) => {
+      data += chunk.toString('utf8');
+      if (!data.includes('\n')) {
+        return;
+      }
+
+      try {
+        const parsed = JSON.parse(data.trim());
+        const status = parsed.TransactionResponse;
+        if (!status || status.id !== id) {
+          finish({ ok: false, submitted: wrote, error: 'peer returned an unexpected transaction response' });
+          return;
+        }
+
+        finish({
+          ok: status.status === 'pending' || status.status === 'confirmed',
+          submitted: status.status === 'pending' || status.status === 'confirmed',
+          verified: true,
+          status: status.status,
+          error: status.error ?? undefined
+        });
+      } catch (error) {
+        finish({ ok: false, submitted: wrote, error: error.message });
+      }
+    });
+    socket.on('timeout', () => finish({ ok: false, submitted: wrote, verified: false, error: 'timeout waiting for transaction response' }));
+    socket.on('error', (error) => finish({ ok: false, submitted: wrote, error: error.message }));
+  });
+}
+
 export async function requestChain(peer) {
   const result = await requestMessage(peer, 'RequestChain', 'ChainResponse');
   return { ...result, chain: result.payload };
@@ -338,6 +403,16 @@ export async function requestPeers(peer) {
   };
 }
 
+export async function requestTransactionStatus(peer, id) {
+  const result = await requestMessage(peer, { RequestTransaction: id }, 'TransactionResponse');
+  return {
+    ...result,
+    transaction: result.payload,
+    status: result.payload?.status,
+    verified: result.ok && (result.payload?.status === 'pending' || result.payload?.status === 'confirmed')
+  };
+}
+
 export async function discoverPeers(seedPeers = DEFAULT_PEERS) {
   const discovered = new Set(normalizePeers(seedPeers));
   let frontier = [...discovered];
@@ -402,7 +477,7 @@ export function calculateBalances(chain) {
       if (transaction.asset_operation) {
         continue;
       }
-      debit(transaction.sender_public_key, transaction.amount);
+      debit(transaction.sender_public_key, transaction.amount + (transaction.fee ?? 0));
       credit(transaction.recipient, transaction.amount);
     }
   }
@@ -525,20 +600,24 @@ export async function getBalance(addressOrWallet, seedPeers = DEFAULT_PEERS) {
   };
 }
 
-export async function assertSpendableXyqonBalance(wallet, amount, seedPeers = DEFAULT_PEERS) {
+export async function assertSpendableXyqonBalance(wallet, amount, seedPeers = DEFAULT_PEERS, fee = 0) {
   const numericAmount = Number(amount);
+  const numericFee = Number(fee);
   const { chain, sourcePeer, peers } = await getBestChain(seedPeers);
   const balances = calculateBalances(chain);
   const balance = balances.get(wallet.public_key) ?? 0;
+  const totalDebit = numericAmount + numericFee;
 
-  if (balance + XYQON_EPSILON < numericAmount) {
+  if (balance + XYQON_EPSILON < totalDebit) {
     throw new Error(
-      `insufficient confirmed XYQON balance; balance is ${balance}, attempted to spend ${numericAmount}`
+      `insufficient confirmed XYQON balance; balance is ${balance}, attempted to spend ${numericAmount} plus fee ${numericFee}`
     );
   }
 
   return {
     balance,
+    fee: numericFee,
+    totalDebit,
     blockHeight: chain.chain.at(-1)?.index ?? 0,
     sourcePeer,
     peers
@@ -613,32 +692,50 @@ export async function getCoinHoldings(addressOrWallet, seedPeers = DEFAULT_PEERS
 
 export async function broadcastTransaction(transaction, seedPeers = DEFAULT_PEERS) {
   const peers = await discoverPeers(seedPeers);
-  const message = { NewTransaction: transaction };
-  const results = await Promise.all(peers.map((peer) => sendNetworkMessage(peer, message)));
+  const id = transactionId(transaction);
+  const results = await Promise.all(peers.map((peer) => sendTransactionMessage(peer, transaction)));
+  const verifiedResults = results.filter((result) => result.verified);
+  const rejectedResults = results.filter((result) => result.status === 'rejected');
 
   return {
-    transactionId: transactionId(transaction),
+    transactionId: id,
     peers,
     results,
-    acceptedBy: results.filter((result) => result.ok).length
+    acceptedBy: verifiedResults.length,
+    verifiedBy: verifiedResults.length,
+    rejectedBy: rejectedResults.length,
+    unverifiedBy: results.filter((result) => result.submitted && !result.verified).length
   };
 }
 
-export async function sendTransaction({ wallet, recipient, amount, peers = DEFAULT_PEERS }) {
-  const transaction = createSignedTransaction(wallet, recipient, amount);
-  const preflight = await assertSpendableXyqonBalance(wallet, transaction.amount, peers);
+function assertBroadcastVerified(broadcast) {
+  if (broadcast.verifiedBy > 0) {
+    return broadcast;
+  }
+
+  const rejection = broadcast.results.find((result) => result.status === 'rejected' && result.error);
+  const failure = rejection ?? broadcast.results.find((result) => result.error);
+  const detail = failure ? ` ${failure.peer}: ${failure.error}` : '';
+  throw new Error(`transaction was not accepted by any reachable XYQON node.${detail}`);
+}
+
+export async function sendTransaction({ wallet, recipient, amount, fee = DEFAULT_XYQON_TRANSACTION_FEE, peers = DEFAULT_PEERS }) {
+  const transaction = createSignedTransaction(wallet, recipient, amount, fee);
+  const preflight = await assertSpendableXyqonBalance(wallet, transaction.amount, peers, transaction.fee);
+  const broadcast = assertBroadcastVerified(await broadcastTransaction(transaction, peers));
   return {
     transaction,
     preflight,
-    ...(await broadcastTransaction(transaction, peers))
+    ...broadcast
   };
 }
 
 export async function createCoin({ wallet, symbol, name, supply, peers = DEFAULT_PEERS }) {
   const transaction = createCoinTransaction(wallet, { symbol, name, supply });
+  const broadcast = assertBroadcastVerified(await broadcastTransaction(transaction, peers));
   return {
     transaction,
-    ...(await broadcastTransaction(transaction, peers))
+    ...broadcast
   };
 }
 
@@ -650,25 +747,28 @@ export async function sendCoin({ wallet, recipient, symbol, amount, peers = DEFA
     transaction.asset_operation.TransferCoin.amount,
     peers
   );
+  const broadcast = assertBroadcastVerified(await broadcastTransaction(transaction, peers));
   return {
     transaction,
     preflight,
-    ...(await broadcastTransaction(transaction, peers))
+    ...broadcast
   };
 }
 
 export async function mintNft({ wallet, collection, tokenId, name, imageUrl = null, peers = DEFAULT_PEERS }) {
   const transaction = createNftMintTransaction(wallet, { collection, tokenId, name, imageUrl });
+  const broadcast = assertBroadcastVerified(await broadcastTransaction(transaction, peers));
   return {
     transaction,
-    ...(await broadcastTransaction(transaction, peers))
+    ...broadcast
   };
 }
 
 export async function transferNft({ wallet, recipient, collection, tokenId, peers = DEFAULT_PEERS }) {
   const transaction = createNftTransferTransaction(wallet, { recipient, collection, tokenId });
+  const broadcast = assertBroadcastVerified(await broadcastTransaction(transaction, peers));
   return {
     transaction,
-    ...(await broadcastTransaction(transaction, peers))
+    ...broadcast
   };
 }