import test from 'node:test';import assert from 'node:assert/strict';import * as ed from '../web/vendor/ed25519.js';import {  b58decode, b58encode, b64encode, concat, decodeSignedDelegate, delegateHash, encodeDelegate,  encodeSignedDelegate, encodeTransaction, hex, outcomeEvents, outcomeFailure, toYocto, TGAS,} from '../web/lib/near.js';const seed = new Uint8Array(32).fill(7);const pub = await ed.getPublicKeyAsync(seed);const fc = { type: 'FunctionCall', method: 'register', args: new TextEncoder().encode('{}'), gas: 30n * TGAS, deposit: toYocto('0.01') };const delegate = { senderId: hex(pub), receiverId: 'dulypay.testnet', actions: [fc], nonce: 5n, maxBlockHeight: 1000n, publicKey: pub };test('base58 round trip, including leading zeros', () => {  for (const b of [[0, 0, 1], [255, 255], [0], [1, 2, 3, 4, 5]]) {    assert.deepEqual([...b58decode(b58encode(Uint8Array.from(b)))], b);  }  assert.throws(() => b58decode('0OIl'));});test('known account key encodes as NEAR does', () => {  // 32 bytes of 1 in base58, from the NEAR docs convention  assert.equal(b58encode(new Uint8Array(32).fill(1)), '4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi');});test('signed delegate survives encode then strict decode', async () => {  const sig = await ed.signAsync(await delegateHash(delegate), seed);  const back = decodeSignedDelegate(encodeSignedDelegate(delegate, sig));  assert.equal(back.delegate.senderId, delegate.senderId);  assert.equal(back.delegate.actions[0].method, 'register');  assert.equal(back.delegate.actions[0].deposit, fc.deposit);  assert.equal(back.delegate.nonce, 5n);  assert.deepEqual([...back.signature], [...sig]);  assert.ok(await ed.verifyAsync(sig, await delegateHash(back.delegate), pub));});test('delegate hash uses the NEP-461 prefix, so it can never equal a transaction hash', async () => {  const body = encodeDelegate(delegate);  const plain = new Uint8Array(await crypto.subtle.digest('SHA-256', body));  assert.notDeepEqual([...plain], [...(await delegateHash(delegate))]);  const prefixed = concat(Uint8Array.of(0x6e, 0x01, 0x00, 0x40), body);  const manual = new Uint8Array(await crypto.subtle.digest('SHA-256', prefixed));  assert.deepEqual([...manual], [...(await delegateHash(delegate))]);});const sig64 = new Uint8Array(64);function encoded(actions) {  return encodeSignedDelegate({ ...delegate, actions }, sig64);}test('strict decoder refuses everything except one function call', () => {  assert.throws(() => decodeSignedDelegate(encoded([fc, fc])), /Exactly one action/);  assert.throws(() => decodeSignedDelegate(encoded([])), /Exactly one action/);  assert.throws(() => decodeSignedDelegate(encoded([{ type: 'Transfer', deposit: 5n }])), /Only function calls/);  assert.throws(() => decodeSignedDelegate(encoded([{ type: 'CreateAccount' }])), /Only function calls/);  assert.throws(() => decodeSignedDelegate(encoded([{ type: 'AddFunctionCallKey', publicKey: pub, allowance: 1n, receiverId: 'a', methods: [] }])), /Only function calls/);  assert.throws(() => decodeSignedDelegate(encoded([{ type: 'DeleteKey', publicKey: pub }])), /Only function calls/);  assert.throws(() => decodeSignedDelegate(encoded([{ type: 'Delegate', delegate, signature: sig64 }])), /Only function calls/);});test('strict decoder refuses trailing and truncated bytes', () => {  const good = encoded([fc]);  assert.throws(() => decodeSignedDelegate(concat(good, Uint8Array.of(0))), /Trailing/);  assert.throws(() => decodeSignedDelegate(good.slice(0, good.length - 1)), /Truncated/);  assert.throws(() => decodeSignedDelegate(new Uint8Array(0)), /Truncated/);});test('strict decoder refuses oversized arguments', () => {  const big = { ...fc, args: new Uint8Array(3000) };  assert.throws(() => decodeSignedDelegate(encoded([big])), /Too long/);});test('transaction encoding has the expected layout', () => {  const t = encodeTransaction({ signerId: 'a', publicKey: pub, nonce: 1n, receiverId: 'b', blockHash: new Uint8Array(32), actions: [{ type: 'Transfer', deposit: 1n }] });  // 4+1 signer, 1+32 key, 8 nonce, 4+1 receiver, 32 hash, 4 count, 1+16 transfer  assert.equal(t.length, 5 + 33 + 8 + 5 + 32 + 4 + 17);  assert.equal(t[5], 0);});test('failure and event extraction', () => {  const outcome = {    transaction_outcome: { outcome: { status: { SuccessReceiptId: 'x' } } },    receipts_outcome: [      { outcome: { status: { SuccessValue: '' }, logs: ['hello', 'EVENT_JSON:{"standard":"duly","event":"invoice_created","data":[{"id":"1-1"}]}', 'EVENT_JSON:{bad', 'EVENT_JSON:{"standard":"nep141","event":"ft_transfer","data":[]}'] } },      { outcome: { status: { Failure: { ActionError: { kind: { FunctionCallError: { ExecutionError: 'Smart contract panicked: Nope' } } } } }, logs: [] } },    ],  };  assert.deepEqual(outcomeEvents(outcome), [{ event: 'invoice_created', data: { id: '1-1' } }]);  assert.ok(outcomeFailure(outcome));});test('toYocto', () => {  assert.equal(toYocto('0.006'), 6_000_000_000_000_000_000_000n);  assert.equal(toYocto('1'), 10n ** 24n);  assert.ok(b64encode(Uint8Array.of(1, 2)).length > 0);});