@geeqdev/geeq-sdk 0.1.0 → 0.2.0

package/dist/src/tx/attestation.js

@@ -0,0 +1,163 @@
+import { blake3 } from '@noble/hashes/blake3';
+import { Message } from 'capnp-ts';
+import { AttestationSubgroup as CapnpAttestationSubgroup, Payload as CapnpPayload, } from '../capnp/payload.capnp';
+import { UserAppTx as CapnpUserAppTx } from '../capnp/userAppTx.capnp';
+import { toBase64 } from '../encoding/base64';
+import { assertMetadataWithinLimits, encodeMetadata } from './metadata';
+import { ATTEST_HASH_BYTES, assertAttestHash } from './content';
+import { REF_HASH_BYTES, assertChainState, assertKeypair, flatten, packed, pinning, resolveChainState, } from './encode';
+import { feeFor } from './fee';
+import { WasmAttestationSubgroupData, WasmPayload, WasmUserAppTx, WasmUserAppTxData, } from '../runtime/bindings';
+import { assertReady, initGeeq } from '../runtime/init';
+import { ACCOUNT_ID_BYTES, PUBLIC_KEY_BYTES } from '../crypto/account-id';
+/**
+ * Build and sign an attestation subgroup: a hash, its labels, and the account vouching
+ * for them. An attestation and an NFT mint carry the same subgroup; it names the signer's
+ * own account in one and the minting proxy in the other.
+ *
+ * Also returns the signature-excluded flatten — what was signed, and what an NFT's id is
+ * the hash of.
+ *
+ * @internal
+ */
+export function signAttestationSubgroup(input) {
+    const { keypair, attestHash, metadata } = input;
+    const message = new Message();
+    const subgroup = message.initRoot(CapnpAttestationSubgroup);
+    const data = subgroup.initData();
+    data.setChainNum(input.chainNumber);
+    data.initAttestHash(ATTEST_HASH_BYTES);
+    data.getAttestHash().copyBuffer(attestHash);
+    data.initAcctNumVal(ACCOUNT_ID_BYTES);
+    data.getAcctNumVal().copyBuffer(input.accountId);
+    data.initPubKey(PUBLIC_KEY_BYTES);
+    data.getPubKey().copyBuffer(keypair.publicKey);
+    data.initMetadata(metadata.length);
+    const metadataList = data.getMetadata();
+    metadata.forEach((item, index) => {
+        const entry = metadataList.get(index);
+        // Subgroup positions are 1-based throughout the protocol, so the first label is
+        // position 1. The node sorts by this field on read, which is what preserves the
+        // order the caller gave.
+        entry.setPosition(index + 1);
+        entry.initItem(item.length);
+        entry.getItem().copyBuffer(item);
+    });
+    // The subgroup is signed over its data alone, before the signature field exists.
+    const flattened = flatten(() => WasmAttestationSubgroupData.fromAttestationSubgroupCapnp(packed(message)), 'attestation subgroup');
+    const signature = keypair.sign(flattened);
+    subgroup.initSignature(signature.length);
+    subgroup.getSignature().copyBuffer(signature);
+    return { subgroup, flattened };
+}
+/**
+ * A payload as it is submitted, the hash its transaction references it by, and its
+ * flattened size, which the fee charges for.
+ *
+ * @internal
+ */
+export function packPayload(message) {
+    const flattened = flatten(() => WasmPayload.fromPayloadCapnp(packed(message)), 'payload');
+    return {
+        payload: toBase64(packed(message)),
+        refHashPayload: blake3(flattened, { dkLen: REF_HASH_BYTES }),
+        bytes: flattened.length,
+    };
+}
+/**
+ * Sign a built application-layer transaction and work out the id the node files it under.
+ * Every application-layer transaction — an attestation, an NFT mint — ends this way.
+ *
+ * @internal
+ */
+export function signAppTx(message, tx, keypair) {
+    // Signed over the signature-EXCLUDED flatten. The node verifies against exactly this
+    // form: its flatten worker swaps in the `…Data` class whenever the signature is left
+    // out, and its signature check asks for the flatten without one.
+    const flattened = flatten(() => WasmUserAppTxData.fromUserAppTxCapnp(packed(message)), 'transaction');
+    const signature = keypair.sign(flattened);
+    tx.initSignature(signature.length);
+    tx.getSignature().copyBuffer(signature);
+    // The chain identifies a transaction by the hash of its signature-INCLUDED flatten —
+    // that is the value its status events carry. Hashing the signing preimage instead
+    // yields a plausible-looking 32 bytes that no node has ever heard of, so this has to
+    // happen after the signature is attached, and through the non-Data class. The same
+    // flatten is what the fee charges for.
+    const signed = flatten(() => WasmUserAppTx.fromUserAppTxCapnp(packed(message)), 'signed transaction');
+    return {
+        transaction: toBase64(packed(message)),
+        transactionHash: blake3(signed, { dkLen: REF_HASH_BYTES }),
+        bytes: signed.length,
+    };
+}
+/**
+ * Build and sign an attestation transaction. Synchronous; requires a loaded engine.
+ *
+ * This function is offline: it opens no sockets and reads no ledger. It needs chain
+ * state that only a node can supply, so either pass the four values yourself or let
+ * {@link GeeqChain} read them and hand you a `chainState`.
+ *
+ * The transaction is signed but **not submitted**. Post
+ * {@link AttestationTx.transaction} and {@link AttestationTx.payload} to the node named
+ * by {@link AttestationTx.nodeUrl}.
+ */
+export function createAttestationTxSync(input) {
+    assertReady('createAttestationTxSync');
+    const { keypair, attestHash } = input;
+    const chainState = resolveChainState(input);
+    const { chainNumber, blockNumber, nodeNumber, nonce } = chainState;
+    assertKeypair(keypair);
+    assertAttestHash(attestHash);
+    assertChainState(chainState);
+    const metadata = encodeMetadata(input.metadata);
+    assertMetadataWithinLimits(metadata, chainState.metadataLimits, { chainNumber, blockNumber });
+    // 1. The attestation subgroup: what is being attested, and by whom. The account's
+    //    identifying record number is the BLAKE3 of its public key, which is exactly the
+    //    account id the keypair already carries.
+    const { subgroup } = signAttestationSubgroup({
+        keypair,
+        attestHash,
+        metadata,
+        chainNumber,
+        accountId: keypair.accountId,
+    });
+    // 2. The payload carries the signed subgroup.
+    const payloadMessage = new Message();
+    const payloadRoot = payloadMessage.initRoot(CapnpPayload);
+    payloadRoot.initTxType().initAttestCommit();
+    payloadRoot.getTxType().getAttestCommit().setAttestationSubgroup(subgroup);
+    const { payload, refHashPayload, bytes: payloadBytes } = packPayload(payloadMessage);
+    // 3. The transaction references the payload by hash rather than carrying it, and
+    //    names the block and node that should process it.
+    const txMessage = new Message();
+    const tx = txMessage.initRoot(CapnpUserAppTx);
+    const txData = tx.getData();
+    txData.initTxType().initAttestCommit();
+    txData.getTxType().getAttestCommit().initAcctNumVal().setNone();
+    txData.setChainNum(chainNumber);
+    txData.setBlockNum(blockNumber);
+    txData.setNodeNum(nodeNumber);
+    txData.setNonce(nonce);
+    txData.initRefHashPayload(refHashPayload.length);
+    txData.getRefHashPayload().copyBuffer(refHashPayload);
+    txData.initPubKey(PUBLIC_KEY_BYTES);
+    txData.getPubKey().copyBuffer(keypair.publicKey);
+    const { transaction, transactionHash, bytes } = signAppTx(txMessage, tx, keypair);
+    return Object.freeze({
+        transaction,
+        payload,
+        refHashPayload,
+        transactionHash,
+        publicKey: keypair.publicKey,
+        // An attestation sends no coin, so it pays only for its bytes: the transaction's and
+        // the payload's.
+        fee: feeFor(bytes + payloadBytes, 0n, chainState.geeqNorm),
+        ...pinning(chainState),
+    });
+}
+/** Build and sign an attestation transaction, loading the engine if needed. */
+export async function createAttestationTx(input) {
+    await initGeeq();
+    return createAttestationTxSync(input);
+}
+//# sourceMappingURL=attestation.js.map

package/dist/src/tx/attestation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attestation.js","sourceRoot":"","sources":["../../../src/tx/attestation.ts"],"names":[],"mappings":"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"}

package/dist/src/tx/content.d.ts

@@ -0,0 +1,27 @@
+/** The protocol attests a 32-byte BLAKE3 digest and rejects any other length. */
+export declare const ATTEST_HASH_BYTES = 32;
+/**
+ * Anything that can be attested.
+ *
+ * A `File` from an `<input type="file">` is a `Blob`, so it can be passed straight in —
+ * there is no need to read it into a buffer first. A string is encoded as UTF-8.
+ */
+export type GeeqContent = Uint8Array | ArrayBuffer | Blob | string;
+/** Read any accepted content into bytes. Async only because a `Blob` requires it. */
+export declare function readContent(content: GeeqContent): Promise<Uint8Array>;
+/**
+ * The digest that goes on chain.
+ *
+ * The content itself never leaves the device; only this does. Pure BLAKE3, so it needs
+ * no engine and no network and works before {@link initGeeq} has resolved — which is
+ * what lets a UI show the digest as someone types.
+ *
+ * Use this rather than calling a hash library directly: the length and the algorithm are
+ * both fixed by the protocol, and a digest of any other width is rejected when the
+ * transaction is built.
+ */
+export declare function attestHashOfSync(content: Uint8Array | ArrayBuffer | string): Uint8Array;
+/** {@link attestHashOfSync}, also accepting a `Blob` or a `File`. */
+export declare function attestHashOf(content: GeeqContent): Promise<Uint8Array>;
+/** Reject a digest the chain would refuse, naming what was wrong. */
+export declare function assertAttestHash(attestHash: unknown): Uint8Array;

package/dist/src/tx/content.js

@@ -0,0 +1,62 @@
+import { blake3 } from '@noble/hashes/blake3';
+import { invalidArgument } from '../errors';
+/** The protocol attests a 32-byte BLAKE3 digest and rejects any other length. */
+export const ATTEST_HASH_BYTES = 32;
+/** Read any accepted content into bytes. Async only because a `Blob` requires it. */
+export async function readContent(content) {
+    if (content instanceof Uint8Array)
+        return content;
+    if (typeof content === 'string')
+        return new TextEncoder().encode(content);
+    if (content instanceof ArrayBuffer)
+        return new Uint8Array(content);
+    if (typeof Blob !== 'undefined' && content instanceof Blob) {
+        return new Uint8Array(await content.arrayBuffer());
+    }
+    throw invalidArgument('content must be a string, a Uint8Array, an ArrayBuffer, or a Blob (which includes ' +
+        'a File from a file input).');
+}
+/**
+ * The digest that goes on chain.
+ *
+ * The content itself never leaves the device; only this does. Pure BLAKE3, so it needs
+ * no engine and no network and works before {@link initGeeq} has resolved — which is
+ * what lets a UI show the digest as someone types.
+ *
+ * Use this rather than calling a hash library directly: the length and the algorithm are
+ * both fixed by the protocol, and a digest of any other width is rejected when the
+ * transaction is built.
+ */
+export function attestHashOfSync(content) {
+    if (typeof Blob !== 'undefined' && content instanceof Blob) {
+        throw invalidArgument('attestHashOfSync cannot read a Blob. Use attestHashOf, which awaits it.');
+    }
+    const bytes = content instanceof Uint8Array
+        ? content
+        : typeof content === 'string'
+            ? new TextEncoder().encode(content)
+            : content instanceof ArrayBuffer
+                ? new Uint8Array(content)
+                : undefined;
+    if (bytes === undefined) {
+        throw invalidArgument('content must be a string, a Uint8Array or an ArrayBuffer. For a Blob or a File, ' +
+            'use attestHashOf.');
+    }
+    return blake3(bytes, { dkLen: ATTEST_HASH_BYTES });
+}
+/** {@link attestHashOfSync}, also accepting a `Blob` or a `File`. */
+export async function attestHashOf(content) {
+    return blake3(await readContent(content), { dkLen: ATTEST_HASH_BYTES });
+}
+/** Reject a digest the chain would refuse, naming what was wrong. */
+export function assertAttestHash(attestHash) {
+    if (!(attestHash instanceof Uint8Array)) {
+        throw invalidArgument('attestHash must be a Uint8Array.');
+    }
+    if (attestHash.length !== ATTEST_HASH_BYTES) {
+        throw invalidArgument(`attestHash must be ${ATTEST_HASH_BYTES} bytes, received ${attestHash.length}. ` +
+            'Use attestHashOf() to produce one.');
+    }
+    return attestHash;
+}
+//# sourceMappingURL=content.js.map

package/dist/src/tx/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","sourceRoot":"","sources":["../../../src/tx/content.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAE7C,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAE3C,iFAAiF;AACjF,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAA;AAUnC,qFAAqF;AACrF,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,OAAoB;IACpD,IAAI,OAAO,YAAY,UAAU;QAAE,OAAO,OAAO,CAAA;IACjD,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACzE,IAAI,OAAO,YAAY,WAAW;QAAE,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,CAAA;IAClE,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,OAAO,YAAY,IAAI,EAAE,CAAC;QAC3D,OAAO,IAAI,UAAU,CAAC,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,CAAA;IACpD,CAAC;IACD,MAAM,eAAe,CACnB,oFAAoF;QAClF,4BAA4B,CAC/B,CAAA;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAA0C;IACzE,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,OAAO,YAAY,IAAI,EAAE,CAAC;QAC3D,MAAM,eAAe,CACnB,yEAAyE,CAC1E,CAAA;IACH,CAAC;IACD,MAAM,KAAK,GACT,OAAO,YAAY,UAAU;QAC3B,CAAC,CAAC,OAAO;QACT,CAAC,CAAC,OAAO,OAAO,KAAK,QAAQ;YAC3B,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC;YACnC,CAAC,CAAC,OAAO,YAAY,WAAW;gBAC9B,CAAC,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC;gBACzB,CAAC,CAAC,SAAS,CAAA;IAEnB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,eAAe,CACnB,kFAAkF;YAChF,mBAAmB,CACtB,CAAA;IACH,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC,CAAA;AACpD,CAAC;AAED,qEAAqE;AACrE,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,OAAoB;IACrD,OAAO,MAAM,CAAC,MAAM,WAAW,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC,CAAA;AACzE,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,gBAAgB,CAAC,UAAmB;IAClD,IAAI,CAAC,CAAC,UAAU,YAAY,UAAU,CAAC,EAAE,CAAC;QACxC,MAAM,eAAe,CAAC,kCAAkC,CAAC,CAAA;IAC3D,CAAC;IACD,IAAI,UAAU,CAAC,MAAM,KAAK,iBAAiB,EAAE,CAAC;QAC5C,MAAM,eAAe,CACnB,sBAAsB,iBAAiB,oBAAoB,UAAU,CAAC,MAAM,IAAI;YAC9E,oCAAoC,CACvC,CAAA;IACH,CAAC;IACD,OAAO,UAAU,CAAA;AACnB,CAAC"}

package/dist/src/tx/encode.d.ts

@@ -0,0 +1,60 @@
+import type { Message } from 'capnp-ts';
+import type { ChainStateInput, GeeqKeypair } from '../types';
+/**
+ * What every transaction builder shares: the checks on its inputs, the Cap'n Proto
+ * packing, the engine's canonical flatten, and the fields every built transaction reports
+ * about what it is pinned to. One copy, so the four builders cannot drift apart.
+ *
+ * @internal
+ */
+/** Every refHash the chain computes is a 32-byte BLAKE3. */
+export declare const REF_HASH_BYTES = 32;
+/** @internal */
+export declare function assertKeypair(keypair: GeeqKeypair): void;
+/** @internal The four numbers a transaction carries are each a uint32 on the wire. */
+export declare function assertChainState(chainState: ChainStateInput): void;
+/** The two shapes a builder accepts chain state in: four numbers, or one object. */
+type FlatOrStateInput = {
+    readonly chainState: ChainStateInput;
+} | {
+    readonly chainState?: never;
+    readonly chainNumber: number;
+    readonly blockNumber: number;
+    readonly nodeNumber: number;
+    readonly nonce: number;
+};
+/**
+ * Normalise the two input shapes into one chain state.
+ *
+ * The flat four-number form is kept for replay and offline signing; the object form is
+ * what a chain read produces. Everything after this sees only the object.
+ *
+ * @internal
+ */
+export declare function resolveChainState(input: FlatOrStateInput): ChainStateInput;
+/**
+ * What a built transaction reports about what it is pinned to: the state itself, frozen,
+ * the last block a node takes it at, and the node it must go to when a chain read chose it.
+ *
+ * @internal
+ */
+export declare function pinning(chainState: ChainStateInput): {
+    readonly chainState: ChainStateInput;
+    readonly validUntilBlock: number;
+    readonly nodeUrl?: string;
+};
+/** @internal A message as it is submitted: Cap'n Proto packed. */
+export declare function packed(message: Message): Uint8Array;
+/**
+ * Flattening is what makes a signature verifiable by the chain: the engine turns a
+ * Cap'n Proto message into the one canonical byte sequence the protocol signs over.
+ * Signing the capnp bytes directly would produce a signature every node rejects,
+ * because packing is not canonical.
+ *
+ * @internal
+ */
+export declare function flatten<T extends {
+    flatten(): Uint8Array;
+    free(): void;
+}>(parse: () => T, what: string): Uint8Array;
+export {};

package/dist/src/tx/encode.js

@@ -0,0 +1,82 @@
+import { assertUint32 } from '../assert';
+import { invalidArgument } from '../errors';
+import { TARGET_BLOCK_SLACK } from './expiry';
+/**
+ * What every transaction builder shares: the checks on its inputs, the Cap'n Proto
+ * packing, the engine's canonical flatten, and the fields every built transaction reports
+ * about what it is pinned to. One copy, so the four builders cannot drift apart.
+ *
+ * @internal
+ */
+/** Every refHash the chain computes is a 32-byte BLAKE3. */
+export const REF_HASH_BYTES = 32;
+/** @internal */
+export function assertKeypair(keypair) {
+    if (keypair === null || typeof keypair !== 'object' || typeof keypair.sign !== 'function') {
+        throw invalidArgument('keypair must be a GeeqKeypair.');
+    }
+}
+/** @internal The four numbers a transaction carries are each a uint32 on the wire. */
+export function assertChainState(chainState) {
+    assertUint32(chainState.chainNumber, 'chainNumber');
+    assertUint32(chainState.blockNumber, 'blockNumber');
+    assertUint32(chainState.nodeNumber, 'nodeNumber');
+    assertUint32(chainState.nonce, 'nonce');
+}
+/**
+ * Normalise the two input shapes into one chain state.
+ *
+ * The flat four-number form is kept for replay and offline signing; the object form is
+ * what a chain read produces. Everything after this sees only the object.
+ *
+ * @internal
+ */
+export function resolveChainState(input) {
+    if (input.chainState !== undefined)
+        return input.chainState;
+    return {
+        chainNumber: input.chainNumber,
+        blockNumber: input.blockNumber,
+        nodeNumber: input.nodeNumber,
+        nonce: input.nonce,
+    };
+}
+/**
+ * What a built transaction reports about what it is pinned to: the state itself, frozen,
+ * the last block a node takes it at, and the node it must go to when a chain read chose it.
+ *
+ * @internal
+ */
+export function pinning(chainState) {
+    return {
+        chainState: Object.freeze({ ...chainState }),
+        validUntilBlock: chainState.blockNumber + TARGET_BLOCK_SLACK,
+        ...(chainState.nodeUrl === undefined ? {} : { nodeUrl: chainState.nodeUrl }),
+    };
+}
+/** @internal A message as it is submitted: Cap'n Proto packed. */
+export function packed(message) {
+    return new Uint8Array(message.toPackedArrayBuffer());
+}
+/**
+ * Flattening is what makes a signature verifiable by the chain: the engine turns a
+ * Cap'n Proto message into the one canonical byte sequence the protocol signs over.
+ * Signing the capnp bytes directly would produce a signature every node rejects,
+ * because packing is not canonical.
+ *
+ * @internal
+ */
+export function flatten(parse, what) {
+    let handle;
+    try {
+        handle = parse();
+        return handle.flatten();
+    }
+    catch (cause) {
+        throw invalidArgument(`Could not encode the ${what} for signing.`, cause);
+    }
+    finally {
+        handle?.free();
+    }
+}
+//# sourceMappingURL=encode.js.map

package/dist/src/tx/encode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../../src/tx/encode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAE3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE7C;;;;;;GAMG;AAEH,4DAA4D;AAC5D,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAA;AAEhC,gBAAgB;AAChB,MAAM,UAAU,aAAa,CAAC,OAAoB;IAChD,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAC1F,MAAM,eAAe,CAAC,gCAAgC,CAAC,CAAA;IACzD,CAAC;AACH,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,gBAAgB,CAAC,UAA2B;IAC1D,YAAY,CAAC,UAAU,CAAC,WAAW,EAAE,aAAa,CAAC,CAAA;IACnD,YAAY,CAAC,UAAU,CAAC,WAAW,EAAE,aAAa,CAAC,CAAA;IACnD,YAAY,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IACjD,YAAY,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;AACzC,CAAC;AAaD;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAuB;IACvD,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC,UAAU,CAAA;IAC3D,OAAO;QACL,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,UAA2B;IAKjD,OAAO;QACL,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,UAAU,EAAE,CAAC;QAC5C,eAAe,EAAE,UAAU,CAAC,WAAW,GAAG,kBAAkB;QAC5D,GAAG,CAAC,UAAU,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC;KAC7E,CAAA;AACH,CAAC;AAED,kEAAkE;AAClE,MAAM,UAAU,MAAM,CAAC,OAAgB;IACrC,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAA;AACtD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CACrB,KAAc,EACd,IAAY;IAEZ,IAAI,MAAqB,CAAA;IACzB,IAAI,CAAC;QACH,MAAM,GAAG,KAAK,EAAE,CAAA;QAChB,OAAO,MAAM,CAAC,OAAO,EAAE,CAAA;IACzB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,eAAe,CAAC,wBAAwB,IAAI,eAAe,EAAE,KAAK,CAAC,CAAA;IAC3E,CAAC;YAAS,CAAC;QACT,MAAM,EAAE,IAAI,EAAE,CAAA;IAChB,CAAC;AACH,CAAC"}

package/dist/src/tx/expiry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * How many blocks the chain may move past a transaction's target block before nodes
+ * refuse it.
+ *
+ * A node accepts a target within `[N-8, N+1]` of its own last committed block N
+ * (geeq_node_core `indicator-function-worker.ts`, Block Target Consistency), and answers
+ * anything older with an HTTP 400 and a `nonsane` status.
+ *
+ * @internal
+ */
+export declare const TARGET_BLOCK_SLACK = 8;

package/dist/src/tx/expiry.js

@@ -0,0 +1,12 @@
+/**
+ * How many blocks the chain may move past a transaction's target block before nodes
+ * refuse it.
+ *
+ * A node accepts a target within `[N-8, N+1]` of its own last committed block N
+ * (geeq_node_core `indicator-function-worker.ts`, Block Target Consistency), and answers
+ * anything older with an HTTP 400 and a `nonsane` status.
+ *
+ * @internal
+ */
+export const TARGET_BLOCK_SLACK = 8;
+//# sourceMappingURL=expiry.js.map

package/dist/src/tx/expiry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiry.js","sourceRoot":"","sources":["../../../src/tx/expiry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAA"}

package/dist/src/tx/fee.d.ts

@@ -0,0 +1,16 @@
+import type { GeeqFee } from '../types';
+/**
+ * What the chain will charge for a transaction, worked out exactly as the node works it out
+ * (geeq_node_core `wrappers/base.ts`, `calculateTransactionFee`):
+ *
+ * - **data** — `geeqNorm` pennies for every byte of the signed, flattened transaction, and
+ *   of its flattened payload when it has one;
+ * - **coin** — a quarter of a percent of the amount sent, rounded down, and never more than
+ *   `geeqNorm × 10⁷` pennies. An attestation sends no amount, so it pays only for its data.
+ *
+ * `undefined` when the chain's `geeqNorm` is not known — the four numbers were supplied by
+ * hand, or the chain does not publish it.
+ *
+ * @internal
+ */
+export declare function feeFor(bytes: number, amount: bigint, geeqNorm: bigint | undefined): GeeqFee | undefined;

package/dist/src/tx/fee.js

@@ -0,0 +1,29 @@
+import { invalidArgument } from '../errors';
+/** The coin part of a fee never exceeds this many times `geeqNorm`, in pennies. */
+const COIN_FEE_CAP = 10000000n;
+/**
+ * What the chain will charge for a transaction, worked out exactly as the node works it out
+ * (geeq_node_core `wrappers/base.ts`, `calculateTransactionFee`):
+ *
+ * - **data** — `geeqNorm` pennies for every byte of the signed, flattened transaction, and
+ *   of its flattened payload when it has one;
+ * - **coin** — a quarter of a percent of the amount sent, rounded down, and never more than
+ *   `geeqNorm × 10⁷` pennies. An attestation sends no amount, so it pays only for its data.
+ *
+ * `undefined` when the chain's `geeqNorm` is not known — the four numbers were supplied by
+ * hand, or the chain does not publish it.
+ *
+ * @internal
+ */
+export function feeFor(bytes, amount, geeqNorm) {
+    if (geeqNorm === undefined)
+        return undefined;
+    if (typeof geeqNorm !== 'bigint' || geeqNorm < 0n) {
+        throw invalidArgument('geeqNorm must be a bigint of zero or more, as the ledger holds it.');
+    }
+    const data = BigInt(bytes) * geeqNorm;
+    const cap = geeqNorm * COIN_FEE_CAP;
+    const coin = amount / 400n < cap ? amount / 400n : cap;
+    return Object.freeze({ total: data + coin, data, coin, bytes });
+}
+//# sourceMappingURL=fee.js.map

package/dist/src/tx/fee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee.js","sourceRoot":"","sources":["../../../src/tx/fee.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAG3C,mFAAmF;AACnF,MAAM,YAAY,GAAG,SAAW,CAAA;AAEhC;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,MAAM,CAAC,KAAa,EAAE,MAAc,EAAE,QAA4B;IAChF,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,SAAS,CAAA;IAC5C,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,GAAG,EAAE,EAAE,CAAC;QAClD,MAAM,eAAe,CAAC,oEAAoE,CAAC,CAAA;IAC7F,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAA;IACrC,MAAM,GAAG,GAAG,QAAQ,GAAG,YAAY,CAAA;IACnC,MAAM,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAA;IACtD,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAA;AACjE,CAAC"}

package/dist/src/tx/metadata.d.ts

@@ -0,0 +1,39 @@
+import type { GeeqMetadataLimits } from '../types';
+/** Labels are kept in the order given and encoded as UTF-8. */
+export declare function encodeMetadata(metadata: readonly (string | Uint8Array)[] | undefined): Uint8Array[];
+/**
+ * Check encoded metadata against the limits the chain publishes in its ledger.
+ *
+ * The node enforces both of these at submit time, so catching them here turns an
+ * opaque HTTP 400 into a message naming the entry and the limit — and does it before
+ * anything is signed. Skipped entirely when the ledger carries no such parameters,
+ * because a missing parameter is a schema difference, not a caller error.
+ */
+export declare function assertMetadataWithinLimits(encoded: readonly Uint8Array[], limits: GeeqMetadataLimits | undefined, context: {
+    readonly chainNumber: number;
+    readonly blockNumber: number;
+}): void;
+/** What one metadata entry costs, and whether the chain would take it. */
+export interface MetadataEntryReport {
+    readonly index: number;
+    /** Length once encoded as UTF-8, which is what the limit is measured in. */
+    readonly bytes: number;
+    readonly overLimit: boolean;
+}
+export interface MetadataReport {
+    readonly entries: readonly MetadataEntryReport[];
+    readonly count: number;
+    readonly tooManyEntries: boolean;
+    readonly withinLimits: boolean;
+    /** Undefined when the chain publishes no limits, in which case nothing is checked. */
+    readonly limits: GeeqMetadataLimits | undefined;
+}
+/**
+ * Measure metadata against a chain's limits without throwing.
+ *
+ * The same rules {@link assertMetadataWithinLimits} enforces, reported rather than
+ * raised, so a UI can colour a field as someone types instead of waiting for a failed
+ * build. Byte lengths are UTF-8, which is the only measure that matters here — a label
+ * of ten emoji is forty bytes, and counting characters would call it short.
+ */
+export declare function inspectMetadata(metadata: readonly (string | Uint8Array)[] | undefined, limits: GeeqMetadataLimits | undefined): MetadataReport;

package/dist/src/tx/metadata.js

@@ -0,0 +1,66 @@
+import { invalidArgument, metadataTooLarge } from '../errors';
+/** Labels are kept in the order given and encoded as UTF-8. */
+export function encodeMetadata(metadata) {
+    if (metadata === undefined)
+        return [];
+    const encoder = new TextEncoder();
+    return metadata.map((item, index) => {
+        if (typeof item === 'string')
+            return encoder.encode(item);
+        if (item instanceof Uint8Array)
+            return item;
+        throw invalidArgument(`metadata[${index}] must be a string or a Uint8Array.`);
+    });
+}
+/**
+ * Check encoded metadata against the limits the chain publishes in its ledger.
+ *
+ * The node enforces both of these at submit time, so catching them here turns an
+ * opaque HTTP 400 into a message naming the entry and the limit — and does it before
+ * anything is signed. Skipped entirely when the ledger carries no such parameters,
+ * because a missing parameter is a schema difference, not a caller error.
+ */
+export function assertMetadataWithinLimits(encoded, limits, context) {
+    if (limits === undefined)
+        return;
+    if (encoded.length > limits.maxEntries) {
+        throw metadataTooLarge(`metadata has ${encoded.length} entries but chain ${context.chainNumber} allows at ` +
+            `most ${limits.maxEntries} (parameter metadataVarNum, read at block ` +
+            `${context.blockNumber}). Remove ${encoded.length - limits.maxEntries}.`);
+    }
+    for (let index = 0; index < encoded.length; index += 1) {
+        const entry = encoded[index];
+        if (entry.length > limits.maxBytesPerEntry) {
+            throw metadataTooLarge(`metadata[${index}] is ${entry.length} bytes but chain ${context.chainNumber} ` +
+                `allows at most ${limits.maxBytesPerEntry} bytes per entry (parameter ` +
+                `metadataVarBytes, read at block ${context.blockNumber}). Characters outside ` +
+                'ASCII cost more than one byte each once encoded as UTF-8, so shorten it.');
+        }
+    }
+}
+/**
+ * Measure metadata against a chain's limits without throwing.
+ *
+ * The same rules {@link assertMetadataWithinLimits} enforces, reported rather than
+ * raised, so a UI can colour a field as someone types instead of waiting for a failed
+ * build. Byte lengths are UTF-8, which is the only measure that matters here — a label
+ * of ten emoji is forty bytes, and counting characters would call it short.
+ */
+export function inspectMetadata(metadata, limits) {
+    const encoded = encodeMetadata(metadata);
+    const maxBytes = limits?.maxBytesPerEntry;
+    const entries = encoded.map((entry, index) => Object.freeze({
+        index,
+        bytes: entry.length,
+        overLimit: maxBytes !== undefined && entry.length > maxBytes,
+    }));
+    const tooManyEntries = limits !== undefined && encoded.length > limits.maxEntries;
+    return Object.freeze({
+        entries: Object.freeze(entries),
+        count: encoded.length,
+        tooManyEntries,
+        withinLimits: !tooManyEntries && !entries.some((entry) => entry.overLimit),
+        limits,
+    });
+}
+//# sourceMappingURL=metadata.js.map

package/dist/src/tx/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../../../src/tx/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAG7D,+DAA+D;AAC/D,MAAM,UAAU,cAAc,CAC5B,QAAsD;IAEtD,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,EAAE,CAAA;IACrC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAA;IACjC,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QAClC,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QACzD,IAAI,IAAI,YAAY,UAAU;YAAE,OAAO,IAAI,CAAA;QAC3C,MAAM,eAAe,CAAC,YAAY,KAAK,qCAAqC,CAAC,CAAA;IAC/E,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CACxC,OAA8B,EAC9B,MAAsC,EACtC,OAAuE;IAEvE,IAAI,MAAM,KAAK,SAAS;QAAE,OAAM;IAEhC,IAAI,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;QACvC,MAAM,gBAAgB,CACpB,gBAAgB,OAAO,CAAC,MAAM,sBAAsB,OAAO,CAAC,WAAW,aAAa;YAClF,QAAQ,MAAM,CAAC,UAAU,4CAA4C;YACrE,GAAG,OAAO,CAAC,WAAW,aAAa,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,UAAU,GAAG,CAC3E,CAAA;IACH,CAAC;IAED,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACvD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAe,CAAA;QAC1C,IAAI,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC;YAC3C,MAAM,gBAAgB,CACpB,YAAY,KAAK,QAAQ,KAAK,CAAC,MAAM,oBAAoB,OAAO,CAAC,WAAW,GAAG;gBAC7E,kBAAkB,MAAM,CAAC,gBAAgB,8BAA8B;gBACvE,mCAAmC,OAAO,CAAC,WAAW,wBAAwB;gBAC9E,0EAA0E,CAC7E,CAAA;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAmBD;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAC7B,QAAsD,EACtD,MAAsC;IAEtC,MAAM,OAAO,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;IACxC,MAAM,QAAQ,GAAG,MAAM,EAAE,gBAAgB,CAAA;IACzC,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAC3C,MAAM,CAAC,MAAM,CAAC;QACZ,KAAK;QACL,KAAK,EAAE,KAAK,CAAC,MAAM;QACnB,SAAS,EAAE,QAAQ,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,QAAQ;KAC7D,CAAC,CACH,CAAA;IACD,MAAM,cAAc,GAAG,MAAM,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,UAAU,CAAA;IAEjF,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;QAC/B,KAAK,EAAE,OAAO,CAAC,MAAM;QACrB,cAAc;QACd,YAAY,EAAE,CAAC,cAAc,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;QAC1E,MAAM;KACP,CAAC,CAAA;AACJ,CAAC"}

package/dist/src/tx/nft.d.ts

@@ -0,0 +1,16 @@
+import type { NftMintTx, NftMintTxInput } from '../types';
+/**
+ * Build and sign an NFT mint. Synchronous; requires a loaded engine.
+ *
+ * An NFT is minted through a proxy, and the proxy is the sender: it pays the fee and
+ * `amount`, which goes to the receiver with the NFT, and it spends its own nonce. Its
+ * admin — the signer here — is the only key the chain accepts for it. The NFT itself is an
+ * attestation subgroup, as an attestation carries: the content's hash and its labels,
+ * signed by the admin and naming the proxy.
+ *
+ * Offline: it cannot check that the proxy exists, is the signer's, or can pay.
+ * {@link GeeqChain.mintNft} does all three.
+ */
+export declare function createNftMintTxSync(input: NftMintTxInput): NftMintTx;
+/** Build and sign an NFT mint, loading the engine if needed. */
+export declare function createNftMintTx(input: NftMintTxInput): Promise<NftMintTx>;