@geeqdev/geeq-sdk 0.1.0 → 0.2.0

package/src/tx/content.ts

@@ -0,0 +1,82 @@
+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
+
+/**
+ * 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 async function readContent(content: GeeqContent): Promise<Uint8Array> {
+  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: Uint8Array | ArrayBuffer | string): Uint8Array {
+  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: GeeqContent): Promise<Uint8Array> {
+  return blake3(await readContent(content), { dkLen: ATTEST_HASH_BYTES })
+}
+
+/** Reject a digest the chain would refuse, naming what was wrong. */
+export function assertAttestHash(attestHash: unknown): Uint8Array {
+  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
+}

package/src/tx/encode.ts

@@ -0,0 +1,107 @@
+import type { Message } from 'capnp-ts'
+
+import { assertUint32 } from '../assert'
+import { invalidArgument } from '../errors'
+import type { ChainStateInput, GeeqKeypair } from '../types'
+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: GeeqKeypair): void {
+  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: ChainStateInput): void {
+  assertUint32(chainState.chainNumber, 'chainNumber')
+  assertUint32(chainState.blockNumber, 'blockNumber')
+  assertUint32(chainState.nodeNumber, 'nodeNumber')
+  assertUint32(chainState.nonce, 'nonce')
+}
+
+/** 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 function resolveChainState(input: FlatOrStateInput): ChainStateInput {
+  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: ChainStateInput): {
+  readonly chainState: ChainStateInput
+  readonly validUntilBlock: number
+  readonly nodeUrl?: string
+} {
+  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: Message): Uint8Array {
+  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<T extends { flatten(): Uint8Array; free(): void }>(
+  parse: () => T,
+  what: string,
+): Uint8Array {
+  let handle: T | undefined
+  try {
+    handle = parse()
+    return handle.flatten()
+  } catch (cause) {
+    throw invalidArgument(`Could not encode the ${what} for signing.`, cause)
+  } finally {
+    handle?.free()
+  }
+}

package/src/tx/expiry.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 const TARGET_BLOCK_SLACK = 8

package/src/tx/fee.ts

@@ -0,0 +1,31 @@
+import { invalidArgument } from '../errors'
+import type { GeeqFee } from '../types'
+
+/** The coin part of a fee never exceeds this many times `geeqNorm`, in pennies. */
+const COIN_FEE_CAP = 10_000_000n
+
+/**
+ * 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: number, amount: bigint, geeqNorm: bigint | undefined): GeeqFee | undefined {
+  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 })
+}

package/src/tx/metadata.ts

@@ -0,0 +1,100 @@
+import { invalidArgument, metadataTooLarge } from '../errors'
+import type { GeeqMetadataLimits } from '../types'
+
+/** Labels are kept in the order given and encoded as UTF-8. */
+export function encodeMetadata(
+  metadata: readonly (string | Uint8Array)[] | undefined,
+): Uint8Array[] {
+  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: readonly Uint8Array[],
+  limits: GeeqMetadataLimits | undefined,
+  context: { readonly chainNumber: number; readonly blockNumber: number },
+): void {
+  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] as Uint8Array
+    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.',
+      )
+    }
+  }
+}
+
+/** 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 function inspectMetadata(
+  metadata: readonly (string | Uint8Array)[] | undefined,
+  limits: GeeqMetadataLimits | undefined,
+): MetadataReport {
+  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,
+  })
+}

package/src/tx/nft.ts

@@ -0,0 +1,108 @@
+import { blake3 } from '@noble/hashes/blake3'
+import { Message } from 'capnp-ts'
+import { Payload as CapnpPayload } from '../capnp/payload.capnp'
+import { UserAppTx as CapnpUserAppTx } from '../capnp/userAppTx.capnp'
+
+import { penniesToUint64 } from '../amount'
+import { ACCOUNT_ID_BYTES, PUBLIC_KEY_BYTES, resolveAccountId } from '../crypto/account-id'
+import { invalidArgument } from '../errors'
+import { assertReady, initGeeq } from '../runtime/init'
+import type { NftMintTx, NftMintTxInput } from '../types'
+import { packPayload, signAppTx, signAttestationSubgroup } from './attestation'
+import { assertAttestHash } from './content'
+import { assertChainState, assertKeypair, pinning } from './encode'
+import { feeFor } from './fee'
+import { assertMetadataWithinLimits, encodeMetadata } from './metadata'
+
+/**
+ * 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 function createNftMintTxSync(input: NftMintTxInput): NftMintTx {
+  assertReady('createNftMintTxSync')
+
+  const { keypair, attestHash, amount, chainState } = input
+  assertKeypair(keypair)
+  const proxyAccountId = resolveAccountId(input.proxyAccountId)
+  const to = resolveAccountId(input.to)
+  assertAttestHash(attestHash)
+  if (typeof amount !== 'bigint' || amount <= 0n) {
+    throw invalidArgument('amount must be a number of pennies greater than zero, as a bigint.')
+  }
+  assertChainState(chainState)
+  const { chainNumber, blockNumber, nodeNumber, nonce } = chainState
+
+  const metadata = encodeMetadata(input.metadata)
+  assertMetadataWithinLimits(metadata, chainState.metadataLimits, { chainNumber, blockNumber })
+
+  // 1. The NFT: what it stands for, signed by the admin and naming the proxy. Its id is the
+  //    hash of the signature-excluded subgroup, as the Geeq wallet computes it.
+  const { subgroup, flattened } = signAttestationSubgroup({
+    keypair,
+    attestHash,
+    metadata,
+    chainNumber,
+    accountId: proxyAccountId,
+  })
+  const nftId = blake3(flattened, { dkLen: ACCOUNT_ID_BYTES })
+
+  // 2. The payload carries the subgroup and the id.
+  const payloadMessage = new Message()
+  const mintPayload = payloadMessage.initRoot(CapnpPayload).initTxType().initNftMint()
+  mintPayload.setAttestationSubgroup(subgroup)
+  mintPayload.initAcctNumApp(ACCOUNT_ID_BYTES)
+  mintPayload.getAcctNumApp().copyBuffer(nftId)
+  const { payload, refHashPayload, bytes: payloadBytes } = packPayload(payloadMessage)
+
+  // 3. The transaction: from the proxy, to the receiver. The nonce is the proxy's, and the
+  //    key is the admin's, which the node checks against the admin the proxy names.
+  const txMessage = new Message()
+  const tx = txMessage.initRoot(CapnpUserAppTx)
+  const txData = tx.getData()
+  const mint = txData.initTxType().initNftMint()
+  mint.setAmtCoin(penniesToUint64(amount))
+  mint.initAcctNumApp(ACCOUNT_ID_BYTES)
+  mint.getAcctNumApp().copyBuffer(nftId)
+  mint.initAcctNumRcv(ACCOUNT_ID_BYTES)
+  mint.getAcctNumRcv().copyBuffer(to)
+  mint.initAcctNumVal(ACCOUNT_ID_BYTES)
+  mint.getAcctNumVal().copyBuffer(proxyAccountId)
+  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,
+    nftId,
+    proxyAccountId,
+    to,
+    amount,
+    fee: feeFor(bytes + payloadBytes, amount, chainState.geeqNorm),
+    ...pinning(chainState),
+  })
+}
+
+/** Build and sign an NFT mint, loading the engine if needed. */
+export async function createNftMintTx(input: NftMintTxInput): Promise<NftMintTx> {
+  await initGeeq()
+  return createNftMintTxSync(input)
+}

package/src/tx/proxy.ts

@@ -0,0 +1,156 @@
+import { Message } from 'capnp-ts'
+import { UserValTx as CapnpUserValTx } from '../capnp/userValTx.capnp'
+
+import { createWalletAddressSync } from '../address/wallet-address'
+import { penniesToUint64 } from '../amount'
+import { assertUint32 } from '../assert'
+import { ACCOUNT_ID_BYTES, PUBLIC_KEY_BYTES } from '../crypto/account-id'
+import { toBase64 } from '../encoding/base64'
+import { invalidArgument } from '../errors'
+import type { GeeqLedger } from '../ledger/geeq-ledger'
+import { WasmIrnRecordType, wasmGenerateIrn } from '../runtime/bindings'
+import { assertReady, initGeeq } from '../runtime/init'
+import type { GeeqNftMintProxies, NftMintProxyTx, NftMintProxyTxInput } from '../types'
+import { assertChainState, assertKeypair, pinning } from './encode'
+import { feeFor } from './fee'
+import { signValidationTx } from './transfer'
+
+/**
+ * How many indexes past the last one found the search keeps going before it decides an
+ * admin's remaining proxies were not derived from its key. Indexes are taken in order, so
+ * a gap is only ever creations that never landed.
+ */
+const MAX_INDEX_GAP = 100
+
+/**
+ * The id of an admin's `index`-th NFT mint proxy.
+ *
+ * Derived rather than random, exactly as the Geeq wallet derives it, so every proxy an
+ * account made can be found again from its key alone. Requires a loaded engine.
+ *
+ * @internal
+ */
+export function nftMintProxyId(adminPublicKey: Uint8Array, index: number): Uint8Array {
+  return wasmGenerateIrn(WasmIrnRecordType.ProxyNftMint, adminPublicKey, index)
+}
+
+/**
+ * An admin's NFT mint proxies in `ledger`, each with its index, and the index the next
+ * one takes. Requires a loaded engine.
+ *
+ * The ledger knows a proxy's admin but not its index, so the index is found by deriving
+ * the admin's ids in order — 1, 2, 3… — until every proxy is matched.
+ *
+ * @internal
+ */
+export function nftMintProxiesIn(
+  ledger: GeeqLedger,
+  admin: { readonly publicKey: Uint8Array },
+): GeeqNftMintProxies {
+  const owned = ledger.findProxyAccounts({ admin })
+  const ids = new Set(owned.map((proxy) => toBase64(proxy.accountId)))
+
+  const indexOf = new Map<string, number>()
+  let index = 0
+  let highest = 0
+  while (indexOf.size < ids.size && index - highest < MAX_INDEX_GAP) {
+    index += 1
+    const id = toBase64(nftMintProxyId(admin.publicKey, index))
+    if (ids.has(id)) {
+      indexOf.set(id, index)
+      highest = index
+    }
+  }
+
+  const proxies = owned
+    .map((proxy) =>
+      Object.freeze({
+        ...proxy,
+        index: indexOf.get(toBase64(proxy.accountId)),
+        address: createWalletAddressSync({
+          accountId: proxy.accountId,
+          chainNumber: ledger.chainNumber,
+          recordType: 'proxy-nft-mint',
+        }),
+      }),
+    )
+    .sort((a, b) => (a.index ?? Number.MAX_SAFE_INTEGER) - (b.index ?? Number.MAX_SAFE_INTEGER))
+
+  return Object.freeze({ proxies, nextIndex: highest + 1 })
+}
+
+/**
+ * Build and sign a transaction that creates an NFT mint proxy. Synchronous; requires a
+ * loaded engine.
+ *
+ * A proxy is a record of its own on the chain. It holds coin, carries its own nonce, and
+ * names one admin — the signer here — who is the only key that can mint NFTs through it.
+ * The signer pays `amount` onto it, plus the fee.
+ *
+ * Offline: it cannot check that the index is unused or that the signer can afford it.
+ * {@link GeeqChain.createNftMintProxy} does both.
+ */
+export function createNftMintProxyTxSync(input: NftMintProxyTxInput): NftMintProxyTx {
+  assertReady('createNftMintProxyTxSync')
+
+  const { keypair, index, amount, chainState } = input
+  assertKeypair(keypair)
+  assertUint32(index, 'index')
+  if (index === 0) {
+    throw invalidArgument("index counts from 1, as the Geeq wallet counts an admin's proxies.")
+  }
+  if (typeof amount !== 'bigint' || amount <= 0n) {
+    throw invalidArgument('amount must be a number of pennies greater than zero, as a bigint.')
+  }
+  assertChainState(chainState)
+  const { chainNumber, blockNumber, nodeNumber, nonce } = chainState
+
+  const message = new Message()
+  const tx = message.initRoot(CapnpUserValTx)
+
+  const data = tx.initData()
+  data.setChainNum(chainNumber)
+  data.setBlockNum(blockNumber)
+  data.setNodeNum(nodeNumber)
+
+  // The nonce and the payer's key sit on the proxy creation itself, as they do on a coin
+  // transfer's asset arm. The new record's id goes in the receiver's slot.
+  const proxyAccountId = nftMintProxyId(keypair.publicKey, index)
+  const create = data.initTx().initProxyCreate()
+  create.setNonce(nonce)
+  create.setAmtCoin(penniesToUint64(amount))
+  create.initAcctNumRcv(ACCOUNT_ID_BYTES)
+  create.getAcctNumRcv().copyBuffer(proxyAccountId)
+  create.initPubKey(PUBLIC_KEY_BYTES)
+  create.getPubKey().copyBuffer(keypair.publicKey)
+
+  // The admin is named by account id. A mint through the proxy is checked against it.
+  const nftMint = create.initTxType().initNftMint()
+  nftMint.initAcctNumAdminUser(ACCOUNT_ID_BYTES)
+  nftMint.getAcctNumAdminUser().copyBuffer(keypair.accountId)
+
+  const { transaction, transactionHash, bytes } = signValidationTx(message, tx, keypair, 'proxy creation')
+
+  return Object.freeze({
+    transaction,
+    transactionHash,
+    publicKey: keypair.publicKey,
+    amount,
+    index,
+    proxyAccountId,
+    proxyAddress: createWalletAddressSync({
+      accountId: proxyAccountId,
+      chainNumber,
+      recordType: 'proxy-nft-mint',
+    }),
+    // The funding counts as the amount sent, so it carries the coin part of the fee too.
+    fee: feeFor(bytes, amount, chainState.geeqNorm),
+    ...pinning(chainState),
+  })
+}
+
+/** Build and sign a proxy creation, loading the engine if needed. */
+export async function createNftMintProxyTx(input: NftMintProxyTxInput): Promise<NftMintProxyTx> {
+  await initGeeq()
+  return createNftMintProxyTxSync(input)
+}