xyqon 0.1.0 → 0.2.0

package/README.md

@@ -8,6 +8,8 @@ It can:
 - Show your public key
 - Check your balance from live public nodes
 - Send a signed transaction to the network
+- Create and send coins on the XYQON network
+- Mint and transfer NFTs
 - Show currently reachable nodes
 
 You do not need to mine and you do not need to run a full node.
@@ -15,13 +17,13 @@ You do not need to mine and you do not need to run a full node.
 ## Install
 
 ```bash
-npm install -g xyqon-client
+npm install -g xyqon
 ```
 
 Or run without installing:
 
 ```bash
-npx xyqon-client help
+npx xyqon help
 ```
 
 ## Create A Wallet
@@ -66,6 +68,37 @@ 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.
 
+## Create And Send Coins
+
+```bash
+xyqon coin create \
+  --symbol GAME \
+  --name "Game Coin" \
+  --supply 1000000
+
+xyqon coin send \
+  --symbol GAME \
+  --to RECIPIENT_PUBLIC_KEY \
+  --amount 25
+```
+
+Coin creation and coin sends are signed 0 XYQON transactions. A miner must include them before the new coin or transfer appears on-chain.
+
+## Mint And Send NFTs
+
+```bash
+xyqon nft mint \
+  --collection ITEMS \
+  --token-id sword-001 \
+  --name "Iron Sword" \
+  --image-url https://example.com/iron-sword.png
+
+xyqon nft send \
+  --collection ITEMS \
+  --token-id sword-001 \
+  --to RECIPIENT_PUBLIC_KEY
+```
+
 ## Show Nodes
 
 ```bash
@@ -95,8 +128,16 @@ import {
   createWallet,
   loadWallet,
   getBalance,
-  sendTransaction
-} from 'xyqon-client';
+  sendTransaction,
+  createCoin,
+  sendCoin,
+  mintNft,
+  transferNft,
+  getCreatedCoins,
+  getCreatedNfts,
+  getOwnedNfts,
+  getCoinHoldings
+} from 'xyqon';
 
 const wallet = createWallet('Cathy');
 console.log(wallet.public_key);
@@ -109,4 +150,38 @@ await sendTransaction({
   recipient: 'RECIPIENT_PUBLIC_KEY',
   amount: 1
 });
+
+await createCoin({
+  wallet,
+  symbol: 'GAME',
+  name: 'Game Coin',
+  supply: 1000000
+});
+
+await sendCoin({
+  wallet,
+  recipient: 'RECIPIENT_PUBLIC_KEY',
+  symbol: 'GAME',
+  amount: 25
+});
+
+await mintNft({
+  wallet,
+  collection: 'ITEMS',
+  tokenId: 'sword-001',
+  name: 'Iron Sword',
+  imageUrl: 'https://example.com/iron-sword.png'
+});
+
+await transferNft({
+  wallet,
+  recipient: 'RECIPIENT_PUBLIC_KEY',
+  collection: 'ITEMS',
+  tokenId: 'sword-001'
+});
+
+const createdCoins = await getCreatedCoins(wallet);
+const createdNfts = await getCreatedNfts(wallet);
+const ownedNfts = await getOwnedNfts(wallet);
+const coinHoldings = await getCoinHoldings(wallet);
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xyqon",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Friendly wallet CLI and JavaScript client for the XYQON network.",
   "keywords": [
     "xyqon",
@@ -23,7 +23,7 @@
   "exports": {
     ".": "./src/index.js"
   },
-  "main": "index.js",
+  "main": "./src/index.js",
   "bin": {
     "xyqon": "src/cli.js",
     "xyqon-client": "src/cli.js"

package/src/cli.js

@@ -3,11 +3,15 @@ import {
   DEFAULT_PEERS,
   DEFAULT_WALLET_PATH,
   createWallet,
+  createCoin,
   discoverPeers,
   getBalance,
   getBestChain,
   loadWallet,
+  mintNft,
   saveWallet,
+  sendCoin,
+  transferNft,
   sendTransaction
 } from './index.js';
 
@@ -39,6 +43,10 @@ ${color('bold', 'Usage')}
   xyqon wallet show [--wallet <FILE>] [--private]
   xyqon balance [--wallet <FILE>] [--address <PUBLIC_KEY>]
   xyqon send --to <PUBLIC_KEY> --amount <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>]
+  xyqon nft send --collection <SYMBOL> --token-id <ID> --to <PUBLIC_KEY> [--wallet <FILE>]
   xyqon nodes
 
 ${color('bold', 'Network options')}
@@ -88,8 +96,8 @@ function peersFromOptions(options) {
 async function run() {
   const argv = process.argv.slice(2);
   const command = argv[0];
-  const subcommand = command === 'wallet' ? argv[1] : undefined;
-  const rest = command === 'wallet' ? argv.slice(2) : argv.slice(1);
+  const subcommand = command === 'wallet' || command === 'coin' || command === 'nft' ? argv[1] : undefined;
+  const rest = command === 'wallet' || command === 'coin' || command === 'nft' ? argv.slice(2) : argv.slice(1);
   const options = parseArgs(rest);
 
   if (!command || command === 'help' || command === '--help' || command === '-h') {
@@ -156,6 +164,120 @@ async function run() {
     return;
   }
 
+  if (command === 'coin' && subcommand === 'create') {
+    if (!options.symbol) {
+      throw new Error('coin create requires --symbol <SYMBOL>');
+    }
+    if (!options.name) {
+      throw new Error('coin create requires --name <NAME>');
+    }
+    if (!options.supply) {
+      throw new Error('coin create requires --supply <AMOUNT>');
+    }
+
+    const wallet = await loadWallet(options.wallet ?? DEFAULT_WALLET_PATH);
+    const result = await createCoin({
+      wallet,
+      symbol: options.symbol,
+      name: options.name,
+      supply: options.supply,
+      peers: peersFromOptions(options)
+    });
+
+    printHero('Coin Created');
+    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`);
+    console.log(color('yellow', 'The coin exists after a miner includes this transaction in a block.'));
+    return;
+  }
+
+  if (command === 'coin' && subcommand === 'send') {
+    if (!options.symbol) {
+      throw new Error('coin send requires --symbol <SYMBOL>');
+    }
+    if (!options.to) {
+      throw new Error('coin send requires --to <PUBLIC_KEY>');
+    }
+    if (!options.amount) {
+      throw new Error('coin send requires --amount <AMOUNT>');
+    }
+
+    const wallet = await loadWallet(options.wallet ?? DEFAULT_WALLET_PATH);
+    const result = await sendCoin({
+      wallet,
+      recipient: options.to,
+      symbol: options.symbol,
+      amount: options.amount,
+      peers: peersFromOptions(options)
+    });
+
+    printHero('Coin Sent');
+    console.log(`${color('bold', 'Amount:')} ${result.transaction.asset_operation.TransferCoin.amount} ${result.transaction.asset_operation.TransferCoin.symbol}`);
+    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`);
+    return;
+  }
+
+  if (command === 'nft' && subcommand === 'mint') {
+    if (!options.collection) {
+      throw new Error('nft mint requires --collection <SYMBOL>');
+    }
+    if (!options['token-id']) {
+      throw new Error('nft mint requires --token-id <ID>');
+    }
+    if (!options.name) {
+      throw new Error('nft mint requires --name <NAME>');
+    }
+
+    const wallet = await loadWallet(options.wallet ?? DEFAULT_WALLET_PATH);
+    const result = await mintNft({
+      wallet,
+      collection: options.collection,
+      tokenId: options['token-id'],
+      name: options.name,
+      imageUrl: options['image-url'],
+      peers: peersFromOptions(options)
+    });
+
+    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`);
+    console.log(color('yellow', 'The NFT exists after a miner includes this transaction in a block.'));
+    return;
+  }
+
+  if (command === 'nft' && subcommand === 'send') {
+    if (!options.collection) {
+      throw new Error('nft send requires --collection <SYMBOL>');
+    }
+    if (!options['token-id']) {
+      throw new Error('nft send requires --token-id <ID>');
+    }
+    if (!options.to) {
+      throw new Error('nft send requires --to <PUBLIC_KEY>');
+    }
+
+    const wallet = await loadWallet(options.wallet ?? DEFAULT_WALLET_PATH);
+    const result = await transferNft({
+      wallet,
+      recipient: options.to,
+      collection: options.collection,
+      tokenId: options['token-id'],
+      peers: peersFromOptions(options)
+    });
+
+    printHero('NFT Sent');
+    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`);
+    return;
+  }
+
   if (command === 'nodes') {
     const peers = await discoverPeers(peersFromOptions(options));
     const { nodes, chain, sourcePeer } = await getBestChain(peers);

package/src/index.js

@@ -60,8 +60,117 @@ export async function loadWallet(path = DEFAULT_WALLET_PATH) {
   return wallet;
 }
 
-export function transactionPayload(sender, recipient, amount, senderPublicKey) {
-  return `${sender}|${recipient}|${Number(amount).toFixed(8)}|${senderPublicKey}`;
+function rustJsonNumber(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) {
+    throw new Error('amount must be a finite number');
+  }
+
+  return Number.isInteger(numeric) ? `${numeric}.0` : `${numeric}`;
+}
+
+function jsonString(value) {
+  return JSON.stringify(`${value}`);
+}
+
+function stringifyAssetOperationForSigning(assetOperation) {
+  if (!assetOperation) {
+    return null;
+  }
+
+  if (assetOperation.CreateCoin) {
+    const coin = assetOperation.CreateCoin;
+    return `{"CreateCoin":{"symbol":${jsonString(coin.symbol)},"name":${jsonString(coin.name)},"supply":${rustJsonNumber(coin.supply)}}}`;
+  }
+
+  if (assetOperation.TransferCoin) {
+    const transfer = assetOperation.TransferCoin;
+    return `{"TransferCoin":{"symbol":${jsonString(transfer.symbol)},"amount":${rustJsonNumber(transfer.amount)}}}`;
+  }
+
+  if (assetOperation.MintNft) {
+    const nft = assetOperation.MintNft;
+    const imageUrl = nft.image_url ? `,"image_url":${jsonString(nft.image_url)}` : '';
+    return `{"MintNft":{"collection":${jsonString(nft.collection)},"token_id":${jsonString(nft.token_id)},"name":${jsonString(nft.name)}${imageUrl}}}`;
+  }
+
+  if (assetOperation.TransferNft) {
+    const transfer = assetOperation.TransferNft;
+    return `{"TransferNft":{"collection":${jsonString(transfer.collection)},"token_id":${jsonString(transfer.token_id)}}}`;
+  }
+
+  throw new Error('unknown asset operation');
+}
+
+export function transactionPayload(sender, recipient, amount, senderPublicKey, assetOperation = null) {
+  const base = `${sender}|${recipient}|${Number(amount).toFixed(8)}|${senderPublicKey}`;
+  const serializedAsset = stringifyAssetOperationForSigning(assetOperation);
+  return serializedAsset ? `${base}|${serializedAsset}` : base;
+}
+
+function assertWalletMatchesPrivateKey(wallet, privateKey) {
+  const senderPublicKey = bytesToHex(ed25519.getPublicKey(privateKey));
+  if (senderPublicKey !== wallet.public_key) {
+    throw new Error('wallet public key does not match its private key');
+  }
+
+  return senderPublicKey;
+}
+
+function createSignedAssetTransaction(wallet, recipient, assetOperation) {
+  const privateKey = hexToBytes(wallet.private_key);
+  const senderPublicKey = assertWalletMatchesPrivateKey(wallet, privateKey);
+  const payload = transactionPayload(wallet.name, recipient, 0, senderPublicKey, assetOperation);
+  const signature = ed25519.sign(new TextEncoder().encode(payload), privateKey);
+
+  return {
+    sender: wallet.name,
+    recipient,
+    amount: 0,
+    sender_public_key: senderPublicKey,
+    signature: bytesToHex(signature),
+    asset_operation: assetOperation
+  };
+}
+
+export function normalizeCoinSymbol(symbol) {
+  const value = `${symbol}`.trim().toUpperCase();
+  if (!/^[A-Z0-9]{2,12}$/.test(value)) {
+    throw new Error('coin symbol must be 2 to 12 letters or numbers');
+  }
+
+  return value;
+}
+
+export function normalizeAssetName(name) {
+  const value = `${name}`.trim();
+  if (!value || value.length > 64) {
+    throw new Error('asset name must be 1 to 64 characters');
+  }
+
+  return value;
+}
+
+export function normalizeTokenId(tokenId) {
+  const value = `${tokenId}`.trim().toLowerCase();
+  if (!/^[a-z0-9_-]{1,64}$/.test(value)) {
+    throw new Error('NFT token id must be 1 to 64 letters, numbers, hyphens, or underscores');
+  }
+
+  return value;
+}
+
+export function normalizeTokenAmount(amount, label = 'amount') {
+  const numeric = Number(amount);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    throw new Error(`${label} must be a positive finite number`);
+  }
+
+  if (Math.round(numeric * 100_000_000) / 100_000_000 !== numeric) {
+    throw new Error(`${label} can have at most 8 decimal places`);
+  }
+
+  return numeric;
 }
 
 export function createSignedTransaction(wallet, recipient, amount) {
@@ -71,10 +180,7 @@ export function createSignedTransaction(wallet, recipient, amount) {
   }
 
   const privateKey = hexToBytes(wallet.private_key);
-  const senderPublicKey = bytesToHex(ed25519.getPublicKey(privateKey));
-  if (senderPublicKey !== wallet.public_key) {
-    throw new Error('wallet public key does not match its private key');
-  }
+  const senderPublicKey = assertWalletMatchesPrivateKey(wallet, privateKey);
 
   const payload = transactionPayload(wallet.name, recipient, numericAmount, senderPublicKey);
   const signature = ed25519.sign(new TextEncoder().encode(payload), privateKey);
@@ -88,6 +194,68 @@ export function createSignedTransaction(wallet, recipient, amount) {
   };
 }
 
+export function createCoinTransaction(wallet, { symbol, name, supply }) {
+  const senderPublicKey = wallet.public_key;
+  const assetOperation = {
+    CreateCoin: {
+      symbol: normalizeCoinSymbol(symbol),
+      name: normalizeAssetName(name),
+      supply: normalizeTokenAmount(supply, 'coin supply')
+    }
+  };
+
+  return createSignedAssetTransaction(wallet, senderPublicKey, assetOperation);
+}
+
+export function createCoinTransferTransaction(wallet, { recipient, symbol, amount }) {
+  if (!recipient) {
+    throw new Error('coin transfer requires a recipient public key');
+  }
+
+  const assetOperation = {
+    TransferCoin: {
+      symbol: normalizeCoinSymbol(symbol),
+      amount: normalizeTokenAmount(amount, 'coin transfer amount')
+    }
+  };
+
+  return createSignedAssetTransaction(wallet, recipient, assetOperation);
+}
+
+export function createNftMintTransaction(wallet, { collection, tokenId, name, imageUrl = null }) {
+  const senderPublicKey = wallet.public_key;
+  const mint = {
+    collection: normalizeCoinSymbol(collection),
+    token_id: normalizeTokenId(tokenId),
+    name: normalizeAssetName(name)
+  };
+
+  if (imageUrl) {
+    const value = `${imageUrl}`.trim();
+    if (value.length > 512 || !/^https?:\/\//i.test(value)) {
+      throw new Error('NFT image URL must start with http:// or https:// and be at most 512 characters');
+    }
+    mint.image_url = value;
+  }
+
+  return createSignedAssetTransaction(wallet, senderPublicKey, { MintNft: mint });
+}
+
+export function createNftTransferTransaction(wallet, { recipient, collection, tokenId }) {
+  if (!recipient) {
+    throw new Error('NFT transfer requires a recipient public key');
+  }
+
+  const assetOperation = {
+    TransferNft: {
+      collection: normalizeCoinSymbol(collection),
+      token_id: normalizeTokenId(tokenId)
+    }
+  };
+
+  return createSignedAssetTransaction(wallet, recipient, assetOperation);
+}
+
 export function transactionId(transaction) {
   return createHash('sha256').update(JSON.stringify(transaction)).digest('hex');
 }
@@ -230,6 +398,9 @@ export function calculateBalances(chain) {
     }
 
     for (const transaction of transactions) {
+      if (transaction.asset_operation) {
+        continue;
+      }
       debit(transaction.sender_public_key, transaction.amount);
       credit(transaction.recipient, transaction.amount);
     }
@@ -238,6 +409,106 @@ export function calculateBalances(chain) {
   return balances;
 }
 
+export function calculateAssets(chain) {
+  const coins = new Map();
+  const nfts = new Map();
+
+  const ensureCoin = (symbol, name = symbol, supply = 0) => {
+    if (!coins.has(symbol)) {
+      coins.set(symbol, { symbol, name, supply, holders: new Map() });
+    }
+    return coins.get(symbol);
+  };
+
+  const addBalance = (symbol, address, amount) => {
+    const coin = ensureCoin(symbol);
+    coin.holders.set(address, (coin.holders.get(address) ?? 0) + amount);
+  };
+
+  for (const block of chain.chain.slice(1)) {
+    for (const transaction of block.transactions.slice(1)) {
+      const operation = transaction.asset_operation;
+      if (!operation) {
+        continue;
+      }
+
+      if (operation.CreateCoin) {
+        const coin = operation.CreateCoin;
+        const symbol = normalizeCoinSymbol(coin.symbol);
+        const record = ensureCoin(symbol, coin.name, coin.supply);
+        record.creator = transaction.sender_public_key;
+        addBalance(symbol, transaction.sender_public_key, coin.supply);
+      } else if (operation.TransferCoin) {
+        const transfer = operation.TransferCoin;
+        const symbol = normalizeCoinSymbol(transfer.symbol);
+        addBalance(symbol, transaction.sender_public_key, -transfer.amount);
+        addBalance(symbol, transaction.recipient, transfer.amount);
+      } else if (operation.MintNft) {
+        const nft = operation.MintNft;
+        const collection = normalizeCoinSymbol(nft.collection);
+        const tokenId = normalizeTokenId(nft.token_id);
+        nfts.set(`${collection}:${tokenId}`, {
+          collection,
+          tokenId,
+          name: nft.name,
+          imageUrl: nft.image_url ?? null,
+          creator: transaction.sender_public_key,
+          owner: transaction.sender_public_key
+        });
+      } else if (operation.TransferNft) {
+        const transfer = operation.TransferNft;
+        const key = `${normalizeCoinSymbol(transfer.collection)}:${normalizeTokenId(transfer.token_id)}`;
+        const nft = nfts.get(key);
+        if (nft) {
+          nft.owner = transaction.recipient;
+        }
+      }
+    }
+  }
+
+  return {
+    coins: [...coins.values()].map((coin) => ({
+      ...coin,
+      creator: coin.creator ?? null,
+      holders: [...coin.holders.entries()]
+        .map(([address, balance]) => ({ address, balance }))
+        .filter((holder) => Math.abs(holder.balance) > 0.00000001)
+        .sort((left, right) => right.balance - left.balance)
+    })),
+    nfts: [...nfts.values()].sort((left, right) =>
+      `${left.collection}:${left.tokenId}`.localeCompare(`${right.collection}:${right.tokenId}`)
+    )
+  };
+}
+
+export function listCoinsCreatedBy(chain, addressOrWallet) {
+  const address = typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key;
+  return calculateAssets(chain).coins.filter((coin) => coin.creator === address);
+}
+
+export function listNftsCreatedBy(chain, addressOrWallet) {
+  const address = typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key;
+  return calculateAssets(chain).nfts.filter((nft) => nft.creator === address);
+}
+
+export function listNftsOwnedBy(chain, addressOrWallet) {
+  const address = typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key;
+  return calculateAssets(chain).nfts.filter((nft) => nft.owner === address);
+}
+
+export function listCoinHoldings(chain, addressOrWallet) {
+  const address = typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key;
+  return calculateAssets(chain).coins
+    .map((coin) => ({
+      symbol: coin.symbol,
+      name: coin.name,
+      supply: coin.supply,
+      creator: coin.creator,
+      balance: coin.holders.find((holder) => holder.address === address)?.balance ?? 0
+    }))
+    .filter((coin) => Math.abs(coin.balance) > 0.00000001);
+}
+
 export async function getBalance(addressOrWallet, seedPeers = DEFAULT_PEERS) {
   const address = typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key;
   const { chain, sourcePeer, peers } = await getBestChain(seedPeers);
@@ -253,6 +524,50 @@ export async function getBalance(addressOrWallet, seedPeers = DEFAULT_PEERS) {
   };
 }
 
+export async function getCreatedCoins(addressOrWallet, seedPeers = DEFAULT_PEERS) {
+  const { chain, sourcePeer, peers } = await getBestChain(seedPeers);
+  return {
+    address: typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key,
+    coins: listCoinsCreatedBy(chain, addressOrWallet),
+    blockHeight: chain.chain.at(-1)?.index ?? 0,
+    sourcePeer,
+    peers
+  };
+}
+
+export async function getCreatedNfts(addressOrWallet, seedPeers = DEFAULT_PEERS) {
+  const { chain, sourcePeer, peers } = await getBestChain(seedPeers);
+  return {
+    address: typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key,
+    nfts: listNftsCreatedBy(chain, addressOrWallet),
+    blockHeight: chain.chain.at(-1)?.index ?? 0,
+    sourcePeer,
+    peers
+  };
+}
+
+export async function getOwnedNfts(addressOrWallet, seedPeers = DEFAULT_PEERS) {
+  const { chain, sourcePeer, peers } = await getBestChain(seedPeers);
+  return {
+    address: typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key,
+    nfts: listNftsOwnedBy(chain, addressOrWallet),
+    blockHeight: chain.chain.at(-1)?.index ?? 0,
+    sourcePeer,
+    peers
+  };
+}
+
+export async function getCoinHoldings(addressOrWallet, seedPeers = DEFAULT_PEERS) {
+  const { chain, sourcePeer, peers } = await getBestChain(seedPeers);
+  return {
+    address: typeof addressOrWallet === 'string' ? addressOrWallet : addressOrWallet.public_key,
+    coins: listCoinHoldings(chain, addressOrWallet),
+    blockHeight: chain.chain.at(-1)?.index ?? 0,
+    sourcePeer,
+    peers
+  };
+}
+
 export async function broadcastTransaction(transaction, seedPeers = DEFAULT_PEERS) {
   const peers = await discoverPeers(seedPeers);
   const message = { NewTransaction: transaction };
@@ -273,3 +588,35 @@ export async function sendTransaction({ wallet, recipient, amount, peers = DEFAU
     ...(await broadcastTransaction(transaction, peers))
   };
 }
+
+export async function createCoin({ wallet, symbol, name, supply, peers = DEFAULT_PEERS }) {
+  const transaction = createCoinTransaction(wallet, { symbol, name, supply });
+  return {
+    transaction,
+    ...(await broadcastTransaction(transaction, peers))
+  };
+}
+
+export async function sendCoin({ wallet, recipient, symbol, amount, peers = DEFAULT_PEERS }) {
+  const transaction = createCoinTransferTransaction(wallet, { recipient, symbol, amount });
+  return {
+    transaction,
+    ...(await broadcastTransaction(transaction, peers))
+  };
+}
+
+export async function mintNft({ wallet, collection, tokenId, name, imageUrl = null, peers = DEFAULT_PEERS }) {
+  const transaction = createNftMintTransaction(wallet, { collection, tokenId, name, imageUrl });
+  return {
+    transaction,
+    ...(await broadcastTransaction(transaction, peers))
+  };
+}
+
+export async function transferNft({ wallet, recipient, collection, tokenId, peers = DEFAULT_PEERS }) {
+  const transaction = createNftTransferTransaction(wallet, { recipient, collection, tokenId });
+  return {
+    transaction,
+    ...(await broadcastTransaction(transaction, peers))
+  };
+}