Developer Documentation

// Wait for wallet extension to initialize
function getProvider() {
  if ('anonyma' in window) {
    return window.anonyma;
  }

  return new Promise(resolve => {
    window.addEventListener('anonyma#initialized', () => {
      resolve(window.anonyma);
    }, { once: true });
  });
}

// Connect to wallet
const provider = await getProvider();
const { address, publicKey } = await provider.connect();
console.log('Connected:', address);

const ws = new WebSocket('wss://rpc.anonyma.network');

ws.addEventListener('open', () => {
  // Subscribe to new blocks
  ws.send(JSON.stringify({ action: 'subscribe', channel: 'block' }));

  // Subscribe to txs for a specific address
  ws.send(JSON.stringify({
    action: 'subscribe',
    channel: 'tx:5Kd7Rv3gmYxBaQEKbr9tcBQ5o3PdFuoCEm34fE2dajXW'
  }));
});

ws.addEventListener('message', (e) => {
  const msg = JSON.parse(e.data);

  if (msg.event === 'newBlock') {
    console.log('New block:', msg.data.index, 'txs:', msg.data.txCount);
  }

  if (msg.event === 'newTransaction') {
    console.log('New tx:', msg.data.transaction.hash);
  }
});

import nacl from 'tweetnacl';
import bs58 from 'bs58';

function verifyTransaction(tx) {
  // Decode the signature and public key from Base58
  const signature = bs58.decode(tx.signature);
  const publicKey = bs58.decode(tx.from); // address = public key
  const hashBytes = bs58.decode(tx.hash);

  // Verify Ed25519 signature
  const valid = nacl.sign.detached.verify(hashBytes, signature, publicKey);

  return valid; // true if signature is authentic
}

// Verify a message signature
function verifyMessage(message, signature, address) {
  const msgBytes = new TextEncoder().encode(message);
  const sigBytes = bs58.decode(signature);
  const pubKey  = bs58.decode(address);

  return nacl.sign.detached.verify(msgBytes, sigBytes, pubKey);
}

// ── 1. Detect & Connect ──
async function initAnonyma() {
  // Wait for extension to inject provider
  const provider = window.anonyma ?? await new Promise(r =>
    window.addEventListener('anonyma#initialized', () => r(window.anonyma), { once: true })
  );

  // Check wallet state
  const state = await provider.getState();
  if (!state.hasWallet) {
    alert('Please create a wallet in the Anonyma extension');
    return;
  }

  // Request connection
  const { address } = await provider.connect();
  console.log('Connected:', address);

  return provider;
}

// ── 2. Send Transaction ──
async function sendPayment(provider, recipient, amountANM) {
  const amountDrops = amountANM * 1_000_000;

  const { hash } = await provider.signAndSendTransaction({
    to: recipient,
    amount: amountDrops,
  });

  console.log('TX submitted:', hash);
  return hash;
}

// ── 3. Listen for Confirmation via WebSocket ──
function waitForConfirmation(txHash, address) {
  return new Promise((resolve) => {
    const ws = new WebSocket('wss://rpc.anonyma.network');

    ws.addEventListener('open', () => {
      ws.send(JSON.stringify({
        action: 'subscribe',
        channel: `tx:${address}`,
      }));
    });

    ws.addEventListener('message', (e) => {
      const msg = JSON.parse(e.data);
      if (msg.data?.transaction?.hash === txHash) {
        console.log('Confirmed in block', msg.data.blockIndex);
        ws.close();
        resolve(msg.data);
      }
    });
  });
}

// ── 4. Usage ──
const provider = await initAnonyma();
const hash = await sendPayment(provider, 'RecipientAddress...', 10);
const confirmation = await waitForConfirmation(hash, 'SenderAddress...');
console.log('All done!', confirmation);