@geeqdev/geeq-sdk 0.1.1 → 0.2.0

package/dist/tests/chain.test.js

@@ -0,0 +1,647 @@
+import { afterEach, beforeAll, describe, expect, it } from '@jest/globals';
+import { blake3 } from '@noble/hashes/blake3';
+import { GeeqChain, attest, createAttestationTx, getExplorerTransaction, initChain, initGeeq, keypairFromMnemonic, } from '../src/index';
+import { NetActorStatus, NetActorType, vllResponse } from './fixtures/build-vll';
+import { fakeTransport, networkError } from './fixtures/fake-transport';
+// A standard BIP-39 test vector. Throwaway — never use it for real funds.
+const MNEMONIC = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+const ENDPOINT = 'https://10.0.0.1:2082';
+const DIRECTORY = 'https://simulator.example.com';
+let keypair;
+beforeAll(async () => {
+    await initGeeq();
+    keypair = await keypairFromMnemonic(MNEMONIC);
+});
+// The default chain is process-wide state; leaking it between tests would make failures
+// depend on file order.
+afterEach(() => {
+    GeeqChain.reset();
+});
+async function failure(promise) {
+    let caught;
+    try {
+        await promise;
+    }
+    catch (error) {
+        caught = error;
+    }
+    if (caught === undefined)
+        throw new Error('expected the call to reject, but it resolved');
+    return caught;
+}
+function ledgerBody(overrides = {}) {
+    return vllResponse({
+        chainNumber: 1,
+        blockNumber: 41,
+        nodes: [{ ip: '10.0.0.1', nodeNumber: 3 }],
+        accounts: [{ accountId: keypair.accountId, kind: 'asset', nonce: 7 }],
+        ...overrides,
+    });
+}
+/** What the directory answers for `chains` then `nodes`. */
+function directoryScript(nodes = [{ ip: '10.0.0.1' }], chains = [
+    { id: 9, chainNumber: 1, name: 'test' },
+], ledger = ledgerBody()) {
+    return (url) => {
+        if (url.includes('/admin/simulation/chains'))
+            return { body: JSON.stringify({ result: chains }) };
+        if (url.includes('/api/nodes')) {
+            return {
+                body: JSON.stringify({
+                    result: nodes.map((n) => ({
+                        ip: n.ip,
+                        port: 3000,
+                        protocol: 'http',
+                        systemId: 9,
+                        publicKey: '',
+                        type: n.type ?? 'active',
+                        status: n.status ?? 'ready',
+                    })),
+                }),
+            };
+        }
+        return { body: ledger };
+    };
+}
+function connect(script = { body: ledgerBody() }) {
+    const transport = fakeTransport(script);
+    return { transport, chain: GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport }) };
+}
+describe('GeeqChain.connect', () => {
+    // The ledger goes stale within a handful of blocks, so reading it at startup would
+    // only mean reading it again later. Connecting is bookkeeping, not I/O.
+    it('reads nothing from the chain', async () => {
+        const { transport, chain } = connect();
+        const geeq = await chain;
+        expect(transport.calls).toHaveLength(0);
+        expect(geeq.endpoint).toBe(ENDPOINT);
+        expect(geeq.node).toBeUndefined();
+        expect(geeq.chainNumber).toBeUndefined();
+    });
+    it('knows the chain number up front when the caller declares one', async () => {
+        const transport = fakeTransport({ body: ledgerBody() });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, chainNumber: 1, transport });
+        expect(geeq.chainNumber).toBe(1);
+    });
+    it('requires exactly one of discovery and endpoint', async () => {
+        const transport = fakeTransport({ body: ledgerBody() });
+        await expect(GeeqChain.connect({ penniesPerGeeq: 1000000000n, transport })).rejects.toMatchObject({
+            code: 'invalid-argument',
+        });
+        await expect(GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, discovery: DIRECTORY, transport })).rejects.toMatchObject({ code: 'invalid-argument' });
+    });
+    // Left to the network layer, each of these surfaces later as an unreachable node — a
+    // negative retries sends nothing, a zero timeout times everything out — which is the
+    // one thing it is not.
+    it.each([
+        ['retries', { retries: -1 }],
+        ['retries', { retries: 1.5 }],
+        ['timeoutMs', { timeoutMs: 0 }],
+        ['timeoutMs', { timeoutMs: Number.NaN }],
+        ['ledgerMaxAgeMs', { ledgerMaxAgeMs: -1 }],
+        ['nodePort', { nodePort: 0 }],
+        ['nodePort', { nodePort: 70_000 }],
+        // What a cleared <input type="number" v-model.number> holds.
+        ['nodePort', { nodePort: '' }],
+        ['chainNumber', { chainNumber: 1.5 }],
+        ['nodeNumber', { nodeNumber: -1 }],
+    ])('refuses a %s of %j before reading anything', async (name, option) => {
+        const transport = fakeTransport({ body: ledgerBody() });
+        const error = await failure(GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport, ...option }));
+        expect(error).toMatchObject({ code: 'invalid-argument' });
+        expect(error.message).toContain(name);
+        expect(transport.calls).toHaveLength(0);
+    });
+});
+describe('abort signals', () => {
+    /** A transport that answers after a few ms and, like fetch, rejects when its signal aborts. */
+    function slowTransport(body) {
+        const calls = [];
+        const transport = (url, init) => {
+            calls.push(url);
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => resolve({ ok: true, status: 200, text: async () => body }), 5);
+                init?.signal?.addEventListener('abort', () => {
+                    clearTimeout(timer);
+                    reject(init.signal?.reason);
+                });
+            });
+        };
+        return Object.assign(transport, { calls });
+    }
+    it('sends nothing for a signal that is already aborted', async () => {
+        const transport = fakeTransport({ body: ledgerBody() });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        const reason = new Error('user left');
+        await expect(geeq.getLedger({ signal: AbortSignal.abort(reason) })).rejects.toBe(reason);
+        await expect(geeq.getChainState({ account: keypair, signal: AbortSignal.abort(reason) })).rejects.toBe(reason);
+        expect(transport.calls).toHaveLength(0);
+    });
+    // The read is shared, so one caller abandoning it must not fail everyone else waiting.
+    it("stops one caller's wait on a shared read without failing the others", async () => {
+        const transport = slowTransport(ledgerBody());
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        const controller = new AbortController();
+        const reason = new Error('this caller left');
+        const leaving = geeq.getLedger({ signal: controller.signal });
+        const staying = geeq.getLedger();
+        controller.abort(reason);
+        // Settled together, so a regression fails the assertions rather than leaving one
+        // promise rejected and unobserved.
+        const [left, stayed] = await Promise.allSettled([leaving, staying]);
+        expect(left).toEqual({ status: 'rejected', reason });
+        expect(stayed).toMatchObject({ status: 'fulfilled', value: { blockNumber: 41 } });
+        expect(transport.calls).toHaveLength(1);
+        // The read ran on and filled the cache for whoever is next.
+        expect(geeq.ledger?.blockNumber).toBe(41);
+    });
+    it("rejects with the caller's own reason when it aborts mid-request", async () => {
+        const transport = slowTransport(ledgerBody());
+        const reason = new Error('navigated away');
+        const controller = new AbortController();
+        const pending = getExplorerTransaction({
+            explorerUrl: 'https://blkexp.example.com',
+            refHash: Buffer.alloc(32, 7).toString('base64'),
+            transport,
+            signal: controller.signal,
+        });
+        controller.abort(reason);
+        await expect(pending).rejects.toBe(reason);
+        expect(transport.calls).toHaveLength(1);
+    });
+});
+describe('node discovery', () => {
+    it('asks the directory for a chain and takes one of its active nodes', async () => {
+        const transport = fakeTransport(directoryScript());
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 1, transport });
+        expect(transport.calls.map((c) => c.url)).toEqual([
+            'https://simulator.example.com/api/admin/simulation/chains',
+            'https://simulator.example.com/api/nodes?systemId=9',
+        ]);
+        expect(geeq.chainNumber).toBe(1);
+        expect(geeq.endpoint).toBe('https://10.0.0.1:2082');
+    });
+    it('never reads a ledger while discovering', async () => {
+        const transport = fakeTransport(directoryScript());
+        await GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 1, transport });
+        expect(transport.calls.some((c) => c.url.includes('type=vll'))).toBe(false);
+    });
+    it('ignores the port the directory reports and uses the node port', async () => {
+        const transport = fakeTransport(directoryScript([{ ip: '10.0.0.7' }]));
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 1, transport });
+        expect(geeq.endpoint).toBe('https://10.0.0.7:2082');
+    });
+    // A directory reached over http is a local or internal deployment, so its nodes are
+    // too; carrying the scheme over is what makes a dev harness work without special
+    // casing, and the port override is there for the same reason.
+    it('addresses nodes with the directory scheme, and an overridable port', async () => {
+        const transport = fakeTransport(directoryScript([{ ip: '127.0.0.1' }]));
+        const geeq = await GeeqChain.connect({
+            penniesPerGeeq: 1000000000n,
+            discovery: 'http://127.0.0.1:9100',
+            chainNumber: 1,
+            nodePort: 9100,
+            transport,
+        });
+        expect(geeq.endpoint).toBe('http://127.0.0.1:9100');
+    });
+    it('only ever picks a node the directory calls active and running', async () => {
+        const transport = fakeTransport(directoryScript([
+            { ip: '10.0.0.1', type: 'listener' },
+            { ip: '10.0.0.2', type: 'relay' },
+            { ip: '10.0.0.3', type: 'active', status: 'stopped' },
+            { ip: '10.0.0.4', type: 'active' },
+        ]));
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 1, transport });
+        expect(geeq.endpoint).toBe('https://10.0.0.4:2082');
+        expect(geeq.candidates).toHaveLength(4);
+    });
+    it('says so when no node can take work, and what it saw', async () => {
+        const transport = fakeTransport(directoryScript([
+            { ip: '10.0.0.1', type: 'listener' },
+            { ip: '10.0.0.2', type: 'active', status: 'stopped' },
+        ]));
+        const error = await failure(GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 1, transport }));
+        expect(error).toMatchObject({ code: 'node-unusable' });
+        expect(error.message).toMatch(/10\.0\.0\.1 \(listener\/ready\)/u);
+        expect(error.message).toMatch(/10\.0\.0\.2 \(active\/stopped\)/u);
+    });
+    describe('choosing a chain by name', () => {
+        const twoChains = [
+            { id: 4, chainNumber: 7, name: 'stage' },
+            { id: 9, chainNumber: 1, name: 'test' },
+        ];
+        it('resolves the name to its protocol number', async () => {
+            const transport = fakeTransport(directoryScript(undefined, twoChains));
+            const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainName: 'test', transport });
+            expect(geeq.chainNumber).toBe(1);
+            expect(geeq.chainName).toBe('test');
+            // systemId 9 is the directory's row for "test" — not its chain number.
+            expect(transport.calls[1]?.url).toMatch(/systemId=9$/u);
+        });
+        it('matches the way a person types it', async () => {
+            const transport = fakeTransport(directoryScript(undefined, twoChains));
+            const geeq = await GeeqChain.connect({
+                penniesPerGeeq: 1000000000n,
+                discovery: DIRECTORY,
+                chainName: '  TEST ',
+                transport,
+            });
+            expect(geeq.chainNumber).toBe(1);
+        });
+        it('lists what it has when the name is unknown', async () => {
+            const transport = fakeTransport(directoryScript(undefined, twoChains));
+            const error = await failure(GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainName: 'prod', transport }));
+            expect(error).toMatchObject({ code: 'invalid-argument' });
+            expect(error.message).toMatch(/no chain named "prod"/u);
+            expect(error.message).toMatch(/stage \(chain 7\), test \(chain 1\)/u);
+        });
+        it('refuses a name that identifies more than one chain', async () => {
+            const transport = fakeTransport(directoryScript(undefined, [
+                { id: 1, chainNumber: 1, name: 'test' },
+                { id: 2, chainNumber: 7, name: 'test' },
+            ]));
+            const error = await failure(GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainName: 'test', transport }));
+            expect(error.message).toMatch(/does not identify one/u);
+        });
+        it('treats a name and a number together as an assertion', async () => {
+            const transport = fakeTransport(directoryScript(undefined, twoChains));
+            const error = await failure(GeeqChain.connect({
+                penniesPerGeeq: 1000000000n,
+                discovery: DIRECTORY,
+                chainName: 'test',
+                chainNumber: 7,
+                transport,
+            }));
+            expect(error.message).toMatch(/"test" is chain 1, but chainNumber was given as 7/u);
+        });
+    });
+    it('needs a chain name or number when the directory lists several', async () => {
+        const transport = fakeTransport(directoryScript(undefined, [
+            { id: 1, chainNumber: 1, name: 'test' },
+            { id: 2, chainNumber: 7, name: 'stage' },
+        ]));
+        const error = await failure(GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, transport }));
+        expect(error).toMatchObject({ code: 'invalid-argument' });
+        expect(error.message).toMatch(/chainName or chainNumber is required/u);
+        expect(error.message).toMatch(/test \(chain 1\), stage \(chain 7\)/u);
+    });
+    it('takes the only chain when there is just one', async () => {
+        const transport = fakeTransport(directoryScript());
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, transport });
+        expect(geeq.chainNumber).toBe(1);
+    });
+    it('reports a chain the directory does not carry', async () => {
+        const transport = fakeTransport(directoryScript());
+        const error = await failure(GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 99, transport }));
+        expect(error.message).toMatch(/does not list chain 99/u);
+    });
+    it('rejects a directory that answers with something else', async () => {
+        const transport = fakeTransport({ body: '<!DOCTYPE html>' });
+        await expect(GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 1, transport })).rejects.toMatchObject({ code: 'node-unusable' });
+    });
+});
+describe('the first ledger read', () => {
+    it('resolves the node number, which the directory cannot supply', async () => {
+        const { transport, chain } = connect();
+        const geeq = await chain;
+        await geeq.getLedger();
+        expect(transport.calls[0]?.url).toBe('https://10.0.0.1:2082/api/blocks?type=vll');
+        expect(geeq.node?.nodeNumber).toBe(3);
+        expect(geeq.node?.processing).toBe(true);
+        expect(geeq.chainNumber).toBe(1);
+    });
+    it('exposes where a transaction must be posted', async () => {
+        const geeq = await connect().chain;
+        await geeq.getLedger();
+        expect(geeq.node?.submitUrl).toBe('https://10.0.0.1:2082/api/blocks/process');
+    });
+    it('refuses a chain that is not the one the caller declared', async () => {
+        const transport = fakeTransport({ body: ledgerBody({ chainNumber: 7 }) });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, chainNumber: 1, transport });
+        await expect(geeq.getLedger()).rejects.toMatchObject({ code: 'chain-mismatch' });
+    });
+    it('refuses when the endpoint turns out to be a listener', async () => {
+        const transport = fakeTransport({
+            body: ledgerBody({
+                nodes: [
+                    {
+                        ip: '10.0.0.1',
+                        nodeNumber: 3,
+                        type: NetActorType.NET_ACTOR_TYPE_ANCHOR_NODE,
+                        status: NetActorStatus.NET_ACTOR_STATUS_LISTENING,
+                    },
+                ],
+            }),
+        });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        await expect(geeq.getLedger()).rejects.toMatchObject({ code: 'node-unusable' });
+    });
+    it('builds a sibling endpoint on the node port, carrying only the scheme', async () => {
+        const geeq = await connect().chain;
+        expect(geeq.endpointFor('10.0.0.9')).toBe('https://10.0.0.9:2082');
+    });
+    it('resolves an endpoint given without a port', async () => {
+        const transport = fakeTransport({ body: ledgerBody() });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: 'https://10.0.0.1', transport });
+        await geeq.getLedger();
+        expect(geeq.endpoint).toBe('https://10.0.0.1:2082');
+        expect(transport.calls[0]?.url).toBe('https://10.0.0.1:2082/api/blocks?type=vll');
+    });
+});
+describe('ledger caching', () => {
+    it('serves a fresh ledger from cache rather than re-reading', async () => {
+        const { transport, chain } = connect();
+        const geeq = await chain;
+        await geeq.getLedger();
+        await geeq.getLedger();
+        expect(transport.calls).toHaveLength(1);
+    });
+    it('re-reads when the cache is disabled', async () => {
+        const { transport, chain } = connect();
+        const geeq = await chain;
+        await geeq.getLedger();
+        await geeq.getLedger({ maxAgeMs: 0 });
+        expect(transport.calls).toHaveLength(2);
+    });
+    it('re-reads on refresh', async () => {
+        const { transport, chain } = connect();
+        const geeq = await chain;
+        await geeq.getLedger();
+        await geeq.refresh();
+        expect(transport.calls).toHaveLength(2);
+    });
+    // Without single-flight, a page building several transactions at once pulls a whole
+    // ledger per build from an endpoint with no rate limiting whatsoever.
+    it('collapses concurrent reads into one request', async () => {
+        const { transport, chain } = connect();
+        const geeq = await chain;
+        await Promise.all([geeq.getLedger(), geeq.getLedger(), geeq.getLedger()]);
+        expect(transport.calls).toHaveLength(1);
+    });
+});
+describe('transport failures', () => {
+    it('retries a transport failure once, then reports all four browser causes', async () => {
+        const transport = fakeTransport(new TypeError('Failed to fetch'));
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        const error = await failure(geeq.getLedger());
+        expect(transport.calls).toHaveLength(2);
+        expect(error).toMatchObject({ code: 'network-unreachable' });
+        expect(error.message).toMatch(/CORS/u);
+        expect(error.message).toMatch(/certificate/u);
+        expect(error.message).toMatch(/https and the node is http/u);
+        expect(error.message).toMatch(/down or the URL is wrong/u);
+    });
+    it('names the real cause instead, when the runtime supplies one', async () => {
+        const transport = fakeTransport(networkError('ECONNREFUSED'));
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        const error = await failure(geeq.getLedger());
+        expect(error.message).toMatch(/ECONNREFUSED/u);
+        expect(error.message).not.toMatch(/four things/u);
+    });
+    it('honours a retries override', async () => {
+        const transport = fakeTransport(new TypeError('Failed to fetch'));
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport, retries: 0 });
+        await failure(geeq.getLedger());
+        expect(transport.calls).toHaveLength(1);
+    });
+    it('does not retry a response — the node has decided', async () => {
+        const transport = fakeTransport({
+            status: 503,
+            body: JSON.stringify({ error: 'x', details: 'Block chain is stopped' }),
+        });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        const error = await failure(geeq.getLedger());
+        expect(transport.calls).toHaveLength(1);
+        expect(error).toMatchObject({
+            code: 'node-error',
+            status: 503,
+            nodeDetails: 'Block chain is stopped',
+        });
+    });
+    it.each([
+        ['an HTML login page', '<!DOCTYPE html>'],
+        ['JSON without a result field', JSON.stringify({ ok: true })],
+        ['a result that is not a string', JSON.stringify({ result: 42 })],
+        ['an empty result', JSON.stringify({ result: '' })],
+    ])('rejects %s as an unreadable ledger', async (_label, body) => {
+        const transport = fakeTransport({ body });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        await expect(geeq.getLedger()).rejects.toMatchObject({ code: 'ledger-unreadable' });
+    });
+});
+describe('getChainState', () => {
+    it('derives all four values from the ledger', async () => {
+        const geeq = await connect().chain;
+        const state = await geeq.getChainState({ account: keypair });
+        expect(state).toMatchObject({
+            chainNumber: 1,
+            blockNumber: 42, // the ledger's 41, plus one
+            ledgerBlockNumber: 41,
+            nodeNumber: 3,
+            nonce: 7,
+            nodeUrl: ENDPOINT,
+        });
+        expect(state.metadataLimits).toEqual({ maxEntries: 4, maxBytesPerEntry: 64 });
+    });
+    it('tells an unfunded account to get funded', async () => {
+        const transport = fakeTransport({ body: ledgerBody({ accounts: [] }) });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        const error = await failure(geeq.getChainState({ account: keypair }));
+        expect(error).toMatchObject({ code: 'account-not-found' });
+        expect(error.message).toMatch(/received coins/u);
+    });
+    const kinds = [
+        ['hl', /hash-lock/u],
+        ['micro', /micro-coin/u],
+        ['asset-empty', /subtype could not be read/u],
+    ];
+    it.each(kinds)('refuses a %s record with an explanation', async (kind, pattern) => {
+        const transport = fakeTransport({
+            body: ledgerBody({ accounts: [{ accountId: keypair.accountId, kind }] }),
+        });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        const error = await failure(geeq.getChainState({ account: keypair }));
+        expect(error).toMatchObject({ code: 'account-not-attestable' });
+        expect(error.message).toMatch(pattern);
+    });
+});
+describe('createAttestation', () => {
+    it('reads the ledger at build time, not before', async () => {
+        const { transport, chain } = connect();
+        const geeq = await chain;
+        expect(transport.calls).toHaveLength(0);
+        await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        expect(transport.calls).toHaveLength(1);
+    });
+    it('produces the same bytes as passing the four values by hand', async () => {
+        const geeq = await connect().chain;
+        const content = new TextEncoder().encode('hello');
+        const derived = await geeq.createAttestation({ keypair, content });
+        const explicit = await createAttestationTx({
+            keypair,
+            attestHash: blake3(content, { dkLen: 32 }),
+            chainNumber: 1,
+            blockNumber: 42,
+            nodeNumber: 3,
+            nonce: 7,
+        });
+        expect(derived.transaction).toBe(explicit.transaction);
+        expect(derived.payload).toBe(explicit.payload);
+    });
+    it('carries the node it must be submitted to', async () => {
+        const geeq = await connect().chain;
+        const tx = await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        expect(tx.nodeUrl).toBe(ENDPOINT);
+    });
+    it('requires exactly one of content and attestHash', async () => {
+        const geeq = await connect().chain;
+        await expect(geeq.createAttestation({ keypair })).rejects.toMatchObject({
+            code: 'invalid-argument',
+        });
+        await expect(geeq.createAttestation({
+            keypair,
+            content: new Uint8Array([1]),
+            attestHash: new Uint8Array(32),
+        })).rejects.toMatchObject({ code: 'invalid-argument' });
+    });
+    it('checks metadata against the chain limits before signing', async () => {
+        const transport = fakeTransport({ body: ledgerBody({ metadataVarNum: 1 }) });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        await expect(geeq.createAttestation({
+            keypair,
+            content: new Uint8Array([1]),
+            metadata: ['one', 'two'],
+        })).rejects.toMatchObject({ code: 'metadata-too-large' });
+    });
+    it('counts metadata in UTF-8 bytes, not characters', async () => {
+        const transport = fakeTransport({ body: ledgerBody({ metadataVarBytes: 4 }) });
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        // Two emoji are 8 bytes once encoded, over a 4-byte limit, despite "looking" short.
+        await expect(geeq.createAttestation({ keypair, content: new Uint8Array([1]), metadata: ['🙂🙂'] })).rejects.toMatchObject({ code: 'metadata-too-large' });
+    });
+    it('works end to end through discovery', async () => {
+        const transport = fakeTransport(directoryScript());
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 1, transport });
+        const tx = await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        expect(tx.nodeUrl).toBe('https://10.0.0.1:2082');
+        expect(tx.chainState).toMatchObject({ chainNumber: 1, nodeNumber: 3, nonce: 7 });
+    });
+});
+describe('the nonce guard', () => {
+    it('refuses a second attestation for one account against one block', async () => {
+        const geeq = await connect().chain;
+        await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        const error = await failure(geeq.createAttestation({ keypair, content: new Uint8Array([2]) }));
+        expect(error).toMatchObject({ code: 'nonce-collision' });
+        expect(error.message).toMatch(/both rejected, not just the second/u);
+    });
+    it('allows the next one once the chain has moved on', async () => {
+        let block = 41;
+        const transport = fakeTransport(() => ({ body: ledgerBody({ blockNumber: block }) }));
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        block = 42;
+        await geeq.refresh();
+        await expect(geeq.createAttestation({ keypair, content: new Uint8Array([2]) })).resolves.toMatchObject({ nodeUrl: ENDPOINT });
+    });
+    // The cache is a few seconds wide, so a caller who waited out the block interval and
+    // tried again would otherwise be told to wait for a block that has already passed.
+    it('looks again before refusing, in case the cached ledger is simply behind', async () => {
+        let block = 41;
+        const transport = fakeTransport(() => ({ body: ledgerBody({ blockNumber: block }) }));
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        block = 42;
+        // No explicit refresh: the collision check re-reads on its own.
+        const second = await geeq.createAttestation({ keypair, content: new Uint8Array([2]) });
+        expect(second.chainState.blockNumber).toBe(43);
+    });
+    it('still refuses when the chain really has not moved', async () => {
+        const { transport, chain } = connect();
+        const geeq = await chain;
+        await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        const before = transport.calls.length;
+        const error = await failure(geeq.createAttestation({ keypair, content: new Uint8Array([2]) }));
+        expect(error).toMatchObject({ code: 'nonce-collision' });
+        // It did look again rather than refusing from cache alone.
+        expect(transport.calls.length).toBeGreaterThan(before);
+    });
+    it('steps aside when the caller names a nonce deliberately', async () => {
+        const geeq = await connect().chain;
+        await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        const second = await geeq.createAttestation({
+            keypair,
+            content: new Uint8Array([2]),
+            nonce: 8,
+        });
+        expect(second.chainState.nonce).toBe(8);
+    });
+    it('can be reset explicitly', async () => {
+        const geeq = await connect().chain;
+        await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        geeq.forgetNonces();
+        await expect(geeq.createAttestation({ keypair, content: new Uint8Array([2]) })).resolves.toBeDefined();
+    });
+    it('takes back the nonce of a build that will not be sent, and builds again on it', async () => {
+        const geeq = await connect().chain;
+        const unsent = await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        geeq.discard(unsent);
+        const rebuilt = await geeq.createAttestation({ keypair, content: new Uint8Array([2]) });
+        expect(rebuilt.chainState.nonce).toBe(unsent.chainState.nonce);
+    });
+    it('takes back only the build it is given', async () => {
+        const geeq = await connect().chain;
+        const first = await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        geeq.discard(first);
+        await geeq.createAttestation({ keypair, content: new Uint8Array([2]) });
+        // Discarding the first again must not release the second's claim.
+        geeq.discard(first);
+        await expect(geeq.createAttestation({ keypair, content: new Uint8Array([3]) })).rejects.toMatchObject({ code: 'nonce-collision' });
+    });
+});
+describe('how long a built transaction lasts', () => {
+    it('carries the last block a node takes it at: its target plus 8', async () => {
+        const geeq = await connect().chain;
+        const tx = await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        expect(tx.chainState.blockNumber).toBe(42);
+        expect(tx.validUntilBlock).toBe(50);
+    });
+    // A node takes a target block within [N-8, N+1] of its own last block N.
+    it('is expired only once the chain is past that block, read afresh', async () => {
+        let block = 41;
+        const transport = fakeTransport(() => ({ body: ledgerBody({ blockNumber: block }) }));
+        const geeq = await GeeqChain.connect({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        const tx = await geeq.createAttestation({ keypair, content: new Uint8Array([1]) });
+        block = 50;
+        await expect(geeq.isExpired(tx)).resolves.toBe(false);
+        // No refresh in between: from cache it would still be block 50.
+        block = 51;
+        await expect(geeq.isExpired(tx)).resolves.toBe(true);
+    });
+});
+describe('the default chain', () => {
+    it('names the call to make when there is no chain yet', () => {
+        expect(() => GeeqChain.current()).toThrow(expect.objectContaining({ code: 'not-initialized' }));
+        expect(() => GeeqChain.current()).toThrow(/GeeqChain\.init/u);
+    });
+    it('is installed by initChain and used by attest', async () => {
+        const transport = fakeTransport(directoryScript());
+        await initChain({ penniesPerGeeq: 1000000000n, discovery: DIRECTORY, chainNumber: 1, transport });
+        expect(GeeqChain.initialized).toBe(true);
+        await expect(attest({ keypair, content: new Uint8Array([1]) })).resolves.toMatchObject({
+            nodeUrl: 'https://10.0.0.1:2082',
+        });
+    });
+    it('is not installed by connect', async () => {
+        await connect().chain;
+        expect(GeeqChain.initialized).toBe(false);
+    });
+    it('stands down when the chain holding the slot is disposed', async () => {
+        const transport = fakeTransport({ body: ledgerBody() });
+        const geeq = await initChain({ penniesPerGeeq: 1000000000n, endpoint: ENDPOINT, transport });
+        geeq.dispose();
+        expect(GeeqChain.initialized).toBe(false);
+    });
+});
+//# sourceMappingURL=chain.test.js.map