Build on the OneEur API.

"ONEEUR-BLOCK-V1"   15 bytes   format name
type                 1 byte    1 = open, 2 = send, 3 = receive
account             key        algorithm (1) + length (2) + public key
height               8 bytes   unsigned big-endian
previous            32 bytes   hash of the previous block
balance             16 bytes   unsigned big-endian, after this block
link                key / 32   send: receiver · open/receive: the send’s hash
memo length          1 byte    0–128
memo                 0–128     UTF-8 text

key       = 0x00 (Ed25519) + 0x0020 (32) + 32-byte public key
hash      = SHA-256(bytes above)
signature = Ed25519(wallet seed, hash)
address   = "oe_ed25519_" + base32(public key + SHA-256(public key)[0..4])
            (RFC 4648 alphabet, lowercase, no padding)

npm install @noble/curves @noble/hashes

import { ed25519 } from '@noble/curves/ed25519.js';
import { sha256 } from '@noble/hashes/sha2.js';
import { bytesToHex, hexToBytes, randomBytes } from '@noble/hashes/utils.js';

const PREFIX = 'oe_ed25519_';
const B32 = 'abcdefghijklmnopqrstuvwxyz234567';

function base32(bytes) {
  let bits = 0, value = 0, out = '';
  for (const b of bytes) {
    value = (value << 8) | b; bits += 8;
    while (bits >= 5) { out += B32[(value >>> (bits - 5)) & 31]; bits -= 5; }
  }
  if (bits > 0) out += B32[(value << (5 - bits)) & 31];
  return out;
}

function unbase32(str) {
  let bits = 0, value = 0; const out = [];
  for (const c of str) {
    const i = B32.indexOf(c);
    if (i < 0) throw new Error('invalid address');
    value = (value << 5) | i; bits += 5;
    if (bits >= 8) { out.push((value >>> (bits - 8)) & 255); bits -= 8; }
  }
  return Uint8Array.from(out);
}

export function encodeAddress(publicKey) {
  const check = sha256(publicKey).slice(0, 4);
  return PREFIX + base32(new Uint8Array([...publicKey, ...check]));
}

export function decodeAddress(address) {
  if (!address.startsWith(PREFIX)) throw new Error('invalid address');
  const raw = unbase32(address.slice(PREFIX.length));
  const key = raw.slice(0, 32), check = raw.slice(32);
  const expected = sha256(key).slice(0, 4);
  if (raw.length !== 36 || check.some((b, i) => b !== expected[i])) throw new Error('invalid address');
  return key;
}

// Keep `seed` secret, e.g. in the device's secure storage.
export function newWallet(seed = randomBytes(32)) {
  const publicKey = ed25519.getPublicKey(seed);
  return { seed, publicKey, address: encodeAddress(publicKey) };
}

const MAGIC = new TextEncoder().encode('ONEEUR-BLOCK-V1');
const TYPES = { open: 1, send: 2, receive: 3 };

function uintBE(value, bytes) {
  const out = new Uint8Array(bytes);
  let v = BigInt(value);
  for (let i = bytes - 1; i >= 0; i--) { out[i] = Number(v & 0xffn); v >>= 8n; }
  return out;
}

export function memoBytes(memo = '') {
  const bytes = new TextEncoder().encode(memo);
  if (bytes.length > 128 || /\p{Cc}/u.test(memo)) throw new Error('bad memo');
  return bytes;
}

// algorithm 0 (Ed25519), 2-byte key length, public key
const key = (publicKey) => [0, publicKey.length >> 8, publicKey.length & 0xff, ...publicKey];

export function signingPayload(b) {
  const memo = memoBytes(b.memo);
  return new Uint8Array([
    ...MAGIC,
    TYPES[b.type],
    ...key(b.account),
    ...uintBE(b.height, 8),
    ...b.previous,
    ...uintBE(b.balance, 16),
    ...(b.type === 'send' ? key(b.link) : b.link),
    memo.length,
    ...memo,
  ]);
}

export function signBlock(wallet, b) {
  const hash = sha256(signingPayload(b));
  return {
    type: b.type,
    algorithm: 'ed25519',
    account: encodeAddress(b.account),
    height: b.height,
    previous: bytesToHex(b.previous),
    balance: b.balance.toString(),
    link: b.type === 'send' ? encodeAddress(b.link) : bytesToHex(b.link),
    memo: b.memo ?? '',
    hash: bytesToHex(hash),
    signature: bytesToHex(ed25519.sign(hash, wallet.seed)),
  };
}

// account: JSON from GET /api/accounts/:address; amount: bigint units
export function sendBlock(wallet, account, toAddress, amount, memo = '') {
  const balance = BigInt(account.balance);
  if (amount <= 0n || amount > balance) throw new Error('bad amount');
  return signBlock(wallet, {
    type: 'send', account: wallet.publicKey, height: account.height + 1,
    previous: hexToBytes(account.head), balance: balance - amount,
    link: decodeAddress(toAddress), memo,
  });
}

// pending: one item from /pending; account: null if the wallet had a 404
export function receiveBlock(wallet, account, pending) {
  const amount = BigInt(pending.amount);
  const link = hexToBytes(pending.send_hash);
  const memo = pending.memo ?? '';
  if (!account) {
    return signBlock(wallet, {
      type: 'open', account: wallet.publicKey, height: 1,
      previous: new Uint8Array(32), balance: amount, link, memo,
    });
  }
  return signBlock(wallet, {
    type: 'receive', account: wallet.publicKey, height: account.height + 1,
    previous: hexToBytes(account.head), balance: BigInt(account.balance) + amount, link, memo,
  });
}

const API = 'https://gateway.oneeur.com';

const account = await (await fetch(`${API}/api/accounts/${me.address}`)).json();
const block = sendBlock(me, account, 'oe_ed25519_…', 150_000_000n, 'Invoice 1042');

const res = await fetch(`${API}/api/blocks`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify(block),
});
console.log(res.status, await res.json());
// 201 { status: 'confirmed', hash: '…', confirmations: 1, holders: 3, confirmed_in_us: 1840 }

Blocks signed with this code give the same hashes as the backend’s own signing code. In another language, rebuild the same bytes and compare your hash with one from /api/transactions.