@geeqdev/geeq-sdk 0.0.1 → 0.1.1

package/src/address/record-type.ts

@@ -0,0 +1,77 @@
+import { invalidArgument } from '../errors'
+import { WasmCoinType, WasmRecordType } from '../runtime/bindings'
+import type { GeeqCoinType, GeeqRecordType } from '../types'
+
+/**
+ * Applications speak in readable record-type names; the protocol speaks in
+ * numbers. This is the only place the two vocabularies meet.
+ */
+const RECORD_TYPE_TO_WASM: Readonly<Record<GeeqRecordType, number>> = {
+  'app-counterparty': WasmRecordType.AppCounterparty,
+  'app-dce': WasmRecordType.AppDce,
+  'app-nft': WasmRecordType.AppNft,
+  'app-stackable': WasmRecordType.AppStackable,
+  'coin-asset': WasmRecordType.CoinAsset,
+  'coin-hl': WasmRecordType.CoinHl,
+  'coin-micro': WasmRecordType.CoinMicro,
+  'gt-nwa': WasmRecordType.GtNwa,
+  'param-boolean': WasmRecordType.ParamBoolean,
+  'param-count-2': WasmRecordType.ParamCount2,
+  'param-count-8': WasmRecordType.ParamCount8,
+  'proxy-nft-mint': WasmRecordType.ProxyNftMint,
+  'proxy-funding': WasmRecordType.ProxyFunding,
+  'proxy-multisig': WasmRecordType.ProxyMultisig,
+  'proxy-dce': WasmRecordType.ProxyDce,
+  'proxy-token-mint': WasmRecordType.ProxyTokenMint,
+  sys: WasmRecordType.Sys,
+}
+
+const WASM_TO_RECORD_TYPE: ReadonlyMap<number, GeeqRecordType> = new Map(
+  (Object.entries(RECORD_TYPE_TO_WASM) as Array<[GeeqRecordType, number]>).map(
+    ([name, value]) => [value, name],
+  ),
+)
+
+/** Every record type this SDK understands, for validation and tooling. */
+export const GEEQ_RECORD_TYPES = Object.freeze(
+  Object.keys(RECORD_TYPE_TO_WASM) as GeeqRecordType[],
+)
+
+export const DEFAULT_RECORD_TYPE: GeeqRecordType = 'coin-asset'
+
+/** @internal */
+export function toWasmRecordType(recordType: GeeqRecordType): number {
+  const value = RECORD_TYPE_TO_WASM[recordType]
+  if (value === undefined) {
+    throw invalidArgument(
+      `Unknown record type "${String(recordType)}". Expected one of: ${GEEQ_RECORD_TYPES.join(', ')}.`,
+    )
+  }
+  return value
+}
+
+/** @internal */
+export function fromWasmRecordType(value: number): GeeqRecordType {
+  const name = WASM_TO_RECORD_TYPE.get(value)
+  if (name === undefined) {
+    throw invalidArgument(
+      `The engine returned record type ${value}, which this SDK version does not know. ` +
+        'Your SDK is probably older than the chain you are talking to.',
+    )
+  }
+  return name
+}
+
+const COIN_TYPE_TO_WASM: Readonly<Record<GeeqCoinType, number>> = {
+  mainnet: WasmCoinType.Mainnet,
+  testnet: WasmCoinType.Testnet,
+}
+
+/** @internal */
+export function toWasmCoinType(coinType: GeeqCoinType): number {
+  const value = COIN_TYPE_TO_WASM[coinType]
+  if (value === undefined) {
+    throw invalidArgument(`Unknown coin type "${String(coinType)}". Expected 'mainnet' or 'testnet'.`)
+  }
+  return value
+}

package/src/address/wallet-address.ts

@@ -0,0 +1,105 @@
+import { GeeqError, invalidAddress, invalidArgument } from '../errors'
+import { WasmWalletAddress } from '../runtime/bindings'
+import { assertReady, initGeeq } from '../runtime/init'
+import { resolveAccountId } from '../crypto/account-id'
+import type { DecodedWalletAddress, GeeqRecordType, WalletAddressOptions } from '../types'
+import { DEFAULT_RECORD_TYPE, fromWasmRecordType, toWasmRecordType } from './record-type'
+
+/** Identify the account either by its public key or by its account id. */
+export type AccountIdentifier =
+  | { readonly publicKey: Uint8Array; readonly accountId?: never }
+  | { readonly accountId: Uint8Array; readonly publicKey?: never }
+
+export type CreateWalletAddressInput = AccountIdentifier & WalletAddressOptions
+
+function assertChainNumber(chainNumber: number): void {
+  if (!Number.isInteger(chainNumber) || chainNumber < 0 || chainNumber > 0xffffffff) {
+    throw invalidArgument(
+      `chainNumber must be an integer between 0 and 4294967295, received ${String(chainNumber)}.`,
+    )
+  }
+}
+
+/**
+ * Build the base58 wallet address for an account. Synchronous; requires the engine
+ * to be loaded already. Most callers want {@link createWalletAddress} instead.
+ */
+export function createWalletAddressSync(input: CreateWalletAddressInput): string {
+  assertReady('createWalletAddressSync')
+  assertChainNumber(input.chainNumber)
+
+  const recordType: GeeqRecordType = input.recordType ?? DEFAULT_RECORD_TYPE
+  const accountId = resolveAccountId(input)
+
+  let address: WasmWalletAddress | undefined
+  try {
+    address = WasmWalletAddress.new(input.chainNumber, toWasmRecordType(recordType), accountId)
+    return address.encode()
+  } catch (cause) {
+    throw invalidAddress(
+      `Could not build a wallet address for record type "${recordType}" on chain ${input.chainNumber}.`,
+      cause,
+    )
+  } finally {
+    address?.free()
+  }
+}
+
+/**
+ * Build the base58 wallet address for an account, loading the engine if needed.
+ *
+ * ```ts
+ * const address = await createWalletAddress({ publicKey, chainNumber: 1 })
+ * ```
+ */
+export async function createWalletAddress(input: CreateWalletAddressInput): Promise<string> {
+  await initGeeq()
+  return createWalletAddressSync(input)
+}
+
+/** Decode a base58 wallet address. Synchronous; requires the engine to be loaded. */
+export function decodeWalletAddressSync(address: string): DecodedWalletAddress {
+  assertReady('decodeWalletAddressSync')
+
+  if (typeof address !== 'string' || address.length === 0) {
+    throw invalidAddress('A wallet address must be a non-empty base58 string.')
+  }
+
+  let decoded: WasmWalletAddress | undefined
+  try {
+    decoded = WasmWalletAddress.decode(address)
+    return Object.freeze({
+      address,
+      chainNumber: decoded.exportChainNum(),
+      recordType: fromWasmRecordType(decoded.exportRecordType()),
+      accountId: decoded.exportAcctNum(),
+    })
+  } catch (cause) {
+    if (cause instanceof GeeqError) throw cause
+    throw invalidAddress(`"${address}" is not a valid Geeq wallet address.`, cause)
+  } finally {
+    decoded?.free()
+  }
+}
+
+/** Decode a base58 wallet address, loading the engine if needed. */
+export async function decodeWalletAddress(address: string): Promise<DecodedWalletAddress> {
+  await initGeeq()
+  return decodeWalletAddressSync(address)
+}
+
+/**
+ * True when `address` decodes as a Geeq wallet address. Requires a loaded engine.
+ *
+ * Throws `not-initialized` rather than answering before the engine has loaded: `false`
+ * would call every address invalid, including good ones.
+ */
+export function isValidWalletAddress(address: string): boolean {
+  try {
+    decodeWalletAddressSync(address)
+    return true
+  } catch (error) {
+    if (error instanceof GeeqError && error.code === 'not-initialized') throw error
+    return false
+  }
+}

package/src/amount.ts

@@ -0,0 +1,143 @@
+import { Uint64 } from 'capnp-ts'
+
+import { invalidArgument } from './errors'
+
+/**
+ * An amount of coin, with its unit stated.
+ *
+ * The protocol counts only **pennies**, as geeq_node_core calls them. A Geeq is a display
+ * unit, and how many pennies make one is not on the chain: the app says, as
+ * `penniesPerGeeq` when it connects, and every conversion takes it from there.
+ *
+ * Every amount crossing this SDK's surface names its unit, because the alternative is a
+ * bare number that means one thing to the caller and another to the chain. That mistake
+ * does not throw — it just moves the wrong amount.
+ *
+ * ```ts
+ * { geeq: "12.34" }     // human-facing: what someone typed
+ * { pennies: balance }  // protocol-facing: as the chain counts it
+ * ```
+ */
+export type GeeqAmount = { readonly geeq: string | number } | { readonly pennies: bigint | number }
+
+/**
+ * @internal The decimal places in a Geeq: the zeros in `penniesPerGeeq`. It must be a
+ * power of ten, so that every amount of pennies has an exact decimal form.
+ */
+export function decimalsOf(penniesPerGeeq: bigint): number {
+  const text = typeof penniesPerGeeq === 'bigint' ? String(penniesPerGeeq) : ''
+  if (!/^10*$/u.test(text)) {
+    throw invalidArgument(
+      `penniesPerGeeq must be a bigint power of ten (1n, 10n, 100n, …), received ${String(penniesPerGeeq)}.`,
+    )
+  }
+  return text.length - 1
+}
+
+/** Parse a decimal Geeq string into pennies. Rejects more precision than exists. */
+function geeqToPennies(value: string | number, penniesPerGeeq: bigint): bigint {
+  const decimals = decimalsOf(penniesPerGeeq)
+  // Numbers go through their string form: 0.1 + 0.2 is not 0.3, and money written as a
+  // float has already lost whatever the float lost.
+  const text = typeof value === 'number' ? String(value) : value.trim()
+
+  if (typeof value === 'number' && !Number.isFinite(value)) {
+    throw invalidArgument(`An amount in geeq must be a finite number, received ${text}.`)
+  }
+  if (typeof value === 'number' && Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw invalidArgument(
+      `${text} is too large to be exact as a JavaScript number, so it may not be what was ` +
+        'typed. Pass it as a string: { geeq: "…" }.',
+    )
+  }
+  if (text.startsWith('-')) {
+    throw invalidArgument(`An amount cannot be negative, received ${text}.`)
+  }
+
+  const match = /^(\d+)(?:\.(\d+))?$/u.exec(text)
+  if (match === null) {
+    throw invalidArgument(
+      `An amount in geeq must be a decimal number such as "12.34", received ${JSON.stringify(text)}.`,
+    )
+  }
+
+  const whole = match[1] as string
+  const fraction = match[2] ?? ''
+  if (fraction.length > decimals) {
+    throw invalidArgument(
+      `${text} has ${fraction.length} decimal places, but at ${penniesPerGeeq} pennies to a ` +
+        `Geeq only ${decimals} are possible. Round it, or give the exact figure as { pennies }.`,
+    )
+  }
+  return BigInt(whole) * penniesPerGeeq + BigInt(fraction.padEnd(decimals, '0'))
+}
+
+/**
+ * Resolve any {@link GeeqAmount} to pennies, the unit the protocol uses. A `{ geeq }`
+ * figure is read at `penniesPerGeeq` to the Geeq; `{ pennies }` is taken as it is.
+ */
+export function toPennies(amount: GeeqAmount, penniesPerGeeq: bigint): bigint {
+  if (amount !== null && typeof amount === 'object') {
+    if ('pennies' in amount) {
+      const { pennies } = amount
+      if (typeof pennies === 'bigint') {
+        if (pennies < 0n) throw invalidArgument(`An amount cannot be negative, received ${pennies}.`)
+        return pennies
+      }
+      if (typeof pennies === 'number') {
+        if (!Number.isInteger(pennies)) {
+          throw invalidArgument(
+            `An amount in pennies must be a whole number, received ${pennies}. Pennies are ` +
+              'already the smallest unit — there is nothing below them.',
+          )
+        }
+        // Above 2^53 a number has already been rounded to its nearest representable
+        // neighbour, so converting it would move a different amount from the one meant.
+        if (!Number.isSafeInteger(pennies)) {
+          throw invalidArgument(
+            `${pennies} pennies is too large to be exact as a JavaScript number. Pass it as ` +
+              'a bigint: { pennies: 123n }.',
+          )
+        }
+        if (pennies < 0) throw invalidArgument(`An amount cannot be negative, received ${pennies}.`)
+        return BigInt(pennies)
+      }
+    }
+    if ('geeq' in amount) return geeqToPennies(amount.geeq, penniesPerGeeq)
+  }
+  throw invalidArgument(
+    'An amount must name its unit: { geeq: "12.34" } or { pennies } as the chain counts them.',
+  )
+}
+
+/**
+ * Format pennies as a decimal Geeq string at `penniesPerGeeq` to the Geeq, the way the Geeq
+ * wallet shows amounts: every place the unit has, trailing zeros dropped.
+ *
+ * A negative figure — a shortfall, say — keeps its sign: `-1.5`, not `-1.-5`.
+ */
+export function formatGeeq(pennies: bigint, penniesPerGeeq: bigint): string {
+  const decimals = decimalsOf(penniesPerGeeq)
+  // Split the magnitude, not the signed value: bigint division truncates toward zero, so
+  // both halves of a negative figure would carry the sign.
+  const sign = pennies < 0n ? '-' : ''
+  const magnitude = pennies < 0n ? -pennies : pennies
+  const whole = magnitude / penniesPerGeeq
+  const fraction = String(magnitude % penniesPerGeeq).padStart(decimals, '0').replace(/0+$/u, '')
+  return fraction === '' ? `${sign}${whole}` : `${sign}${whole}.${fraction}`
+}
+
+/** @internal Read a Cap'n Proto UInt64 as a bigint. Little-endian, as the protocol writes it. */
+export function uint64ToPennies(value: Uint64): bigint {
+  return value.toDataView().getBigUint64(0, true)
+}
+
+/** @internal Write pennies as a Cap'n Proto UInt64. */
+export function penniesToUint64(pennies: bigint): Uint64 {
+  if (pennies < 0n || pennies > 0xffffffffffffffffn) {
+    throw invalidArgument(`An amount must fit in a uint64, received ${pennies} pennies.`)
+  }
+  const view = new DataView(new ArrayBuffer(8))
+  view.setBigUint64(0, pennies, true)
+  return Uint64.fromDataView(view)
+}

package/src/assert.ts

@@ -0,0 +1,30 @@
+import { invalidArgument } from './errors'
+
+/**
+ * Argument checks shared across layers. Each one names the argument and what it received,
+ * so the message points at the caller's data rather than at this file.
+ *
+ * @internal
+ */
+
+/** The largest value the protocol's 32-bit fields hold: chain, block, node, nonce, index. */
+export const MAX_UINT32 = 0xffffffff
+
+/** @internal */
+export function assertUint32(value: number, label: string): void {
+  if (!Number.isInteger(value) || value < 0 || value > MAX_UINT32) {
+    throw invalidArgument(
+      `${label} must be an integer between 0 and ${MAX_UINT32}, received ${String(value)}.`,
+    )
+  }
+}
+
+/** @internal An optional option in milliseconds. Undefined means "use the default". */
+export function assertDuration(value: number | undefined, label: string): void {
+  if (value === undefined) return
+  if (!Number.isFinite(value) || value < 0) {
+    throw invalidArgument(
+      `${label} must be a non-negative number of milliseconds, received ${String(value)}.`,
+    )
+  }
+}

package/src/capnp/README.md

@@ -0,0 +1,15 @@
+# Cap'n Proto schemas (vendored)
+
+Generated TypeScript bindings for the Geeq protocol messages, copied verbatim from the
+`generated/` directory of the private `geeq_capnp_ts` repository so the published SDK
+depends on nothing outside the public npm registry.
+
+| | |
+|---|---|
+| Source | `bitbucket.org/bigkraken5/geeq_capnp_ts`, branch `app-15` |
+| Commit | `91c2ddd25d66b64019c78ddcb27157767e506d26` |
+
+Do not edit these files by hand. To update, copy `generated/*.capnp.ts` from the new
+commit over this directory, update the commit above, and run `npm run typecheck`,
+`npm test` and `npm run build && npm run smoke`. The schemas must match the protocol
+version of the WASM engine in `src/wasm`.

package/src/capnp/adminNetTx.capnp.ts

@@ -0,0 +1,66 @@
+/* tslint:disable */
+
+/**
+ * This file has been automatically generated by the [capnpc-ts utility](https://github.com/jdiaz5513/capnp-ts).
+ */
+
+import * as capnp from "capnp-ts";
+import { ObjectSize as __O, Struct as __S } from 'capnp-ts';
+export const _capnpFileId = "a0821f452231cb39";
+export enum AuditCode {
+    AUDIT_CODE_EQUIVOCATION,
+    AUDIT_CODE_HCS_CSV,
+    AUDIT_CODE_HUB_DISHONEST,
+    AUDIT_CODE_NCS_CSV,
+    AUDIT_CODE_NODE_DISHONEST,
+    AUDIT_CODE_RCS_CSV,
+    AUDIT_CODE_RELAY_DISHONEST
+}
+export class AuditAdminNetTx extends __S {
+    static readonly _capnp = { displayName: "AuditAdminNetTx", id: "b7d1c71a0cf819b7", size: new __O(16, 1) };
+    getAmtCoin(): capnp.Uint64 { return __S.getUint64(0, this); }
+    setAmtCoin(value: capnp.Uint64): void { __S.setUint64(0, value, this); }
+    getNodeNum(): number { return __S.getUint32(8, this); }
+    setNodeNum(value: number): void { __S.setUint32(8, value, this); }
+    getAuditCode(): AuditCode { return __S.getUint16(12, this); }
+    setAuditCode(value: AuditCode): void { __S.setUint16(12, value, this); }
+    adoptAcctNumSend(value: capnp.Orphan<capnp.Data>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownAcctNumSend(): capnp.Orphan<capnp.Data> { return __S.disown(this.getAcctNumSend()); }
+    getAcctNumSend(): capnp.Data { return __S.getData(0, this); }
+    hasAcctNumSend(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initAcctNumSend(length: number): capnp.Data { return __S.initData(0, length, this); }
+    setAcctNumSend(value: capnp.Data): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    toString(): string { return "AuditAdminNetTx_" + super.toString(); }
+}
+export class FeeDistAdminNetTx extends __S {
+    static readonly _capnp = { displayName: "FeeDistAdminNetTx", id: "da1ade52d59dba3b", size: new __O(16, 1) };
+    getAmtCoin(): capnp.Uint64 { return __S.getUint64(0, this); }
+    setAmtCoin(value: capnp.Uint64): void { __S.setUint64(0, value, this); }
+    getNodeNum(): number { return __S.getUint32(8, this); }
+    setNodeNum(value: number): void { __S.setUint32(8, value, this); }
+    adoptAcctNumRcv(value: capnp.Orphan<capnp.Data>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownAcctNumRcv(): capnp.Orphan<capnp.Data> { return __S.disown(this.getAcctNumRcv()); }
+    getAcctNumRcv(): capnp.Data { return __S.getData(0, this); }
+    hasAcctNumRcv(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initAcctNumRcv(length: number): capnp.Data { return __S.initData(0, length, this); }
+    setAcctNumRcv(value: capnp.Data): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    toString(): string { return "FeeDistAdminNetTx_" + super.toString(); }
+}
+export class RfdAdminNetTx extends __S {
+    static readonly _capnp = { displayName: "RfdAdminNetTx", id: "cab22a89a36ebee1", size: new __O(8, 2) };
+    getAmtCoin(): capnp.Uint64 { return __S.getUint64(0, this); }
+    setAmtCoin(value: capnp.Uint64): void { __S.setUint64(0, value, this); }
+    adoptAcctNumSend(value: capnp.Orphan<capnp.Data>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownAcctNumSend(): capnp.Orphan<capnp.Data> { return __S.disown(this.getAcctNumSend()); }
+    getAcctNumSend(): capnp.Data { return __S.getData(0, this); }
+    hasAcctNumSend(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initAcctNumSend(length: number): capnp.Data { return __S.initData(0, length, this); }
+    setAcctNumSend(value: capnp.Data): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    adoptAcctNumRcv(value: capnp.Orphan<capnp.Data>): void { __S.adopt(value, __S.getPointer(1, this)); }
+    disownAcctNumRcv(): capnp.Orphan<capnp.Data> { return __S.disown(this.getAcctNumRcv()); }
+    getAcctNumRcv(): capnp.Data { return __S.getData(1, this); }
+    hasAcctNumRcv(): boolean { return !__S.isNull(__S.getPointer(1, this)); }
+    initAcctNumRcv(length: number): capnp.Data { return __S.initData(1, length, this); }
+    setAcctNumRcv(value: capnp.Data): void { __S.copyFrom(value, __S.getPointer(1, this)); }
+    toString(): string { return "RfdAdminNetTx_" + super.toString(); }
+}

package/src/capnp/appLayBlock.capnp.ts

@@ -0,0 +1,26 @@
+/* tslint:disable */
+
+/**
+ * This file has been automatically generated by the [capnpc-ts utility](https://github.com/jdiaz5513/capnp-ts).
+ */
+
+import * as capnp from "capnp-ts";
+import { ObjectSize as __O, Struct as __S } from 'capnp-ts';
+import { NodePayloadList } from "./nodePayloadList.capnp";
+export const _capnpFileId = "c58bc266447b8f2d";
+export class AppLayBlock extends __S {
+    static readonly _capnp = { displayName: "AppLayBlock", id: "e47b52b5ebbd566c", size: new __O(8, 1) };
+    static _NodePayloadLists: capnp.ListCtor<NodePayloadList>;
+    getBlockNum(): number { return __S.getUint32(0, this); }
+    setBlockNum(value: number): void { __S.setUint32(0, value, this); }
+    getChainNum(): number { return __S.getUint32(4, this); }
+    setChainNum(value: number): void { __S.setUint32(4, value, this); }
+    adoptNodePayloadLists(value: capnp.Orphan<capnp.List<NodePayloadList>>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownNodePayloadLists(): capnp.Orphan<capnp.List<NodePayloadList>> { return __S.disown(this.getNodePayloadLists()); }
+    getNodePayloadLists(): capnp.List<NodePayloadList> { return __S.getList(0, AppLayBlock._NodePayloadLists, this); }
+    hasNodePayloadLists(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initNodePayloadLists(length: number): capnp.List<NodePayloadList> { return __S.initList(0, AppLayBlock._NodePayloadLists, length, this); }
+    setNodePayloadLists(value: capnp.List<NodePayloadList>): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    toString(): string { return "AppLayBlock_" + super.toString(); }
+}
+AppLayBlock._NodePayloadLists = capnp.CompositeList(NodePayloadList);

package/src/capnp/appLayLedger.capnp.ts

@@ -0,0 +1,35 @@
+/* tslint:disable */
+
+/**
+ * This file has been automatically generated by the [capnpc-ts utility](https://github.com/jdiaz5513/capnp-ts).
+ */
+
+import * as capnp from "capnp-ts";
+import { ObjectSize as __O, Struct as __S } from 'capnp-ts';
+import { AppCounterpartyRec, AppDceRec, AppNftRec, AppStackableRec, AppLayRec } from "./appLayRec.capnp";
+import { ByteString } from "./misc.capnp";
+export const _capnpFileId = "a45ad15476ce444c";
+export class AppLayLedger extends __S {
+    static readonly _capnp = { displayName: "AppLayLedger", id: "93328856bc57f4b3", size: new __O(8, 2) };
+    static _TokenNames: capnp.ListCtor<ByteString>;
+    static _AppLayRecs: capnp.ListCtor<AppLayRec>;
+    getBlockNum(): number { return __S.getUint32(0, this); }
+    setBlockNum(value: number): void { __S.setUint32(0, value, this); }
+    getChainNum(): number { return __S.getUint32(4, this); }
+    setChainNum(value: number): void { __S.setUint32(4, value, this); }
+    adoptTokenNames(value: capnp.Orphan<capnp.List<ByteString>>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownTokenNames(): capnp.Orphan<capnp.List<ByteString>> { return __S.disown(this.getTokenNames()); }
+    getTokenNames(): capnp.List<ByteString> { return __S.getList(0, AppLayLedger._TokenNames, this); }
+    hasTokenNames(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initTokenNames(length: number): capnp.List<ByteString> { return __S.initList(0, AppLayLedger._TokenNames, length, this); }
+    setTokenNames(value: capnp.List<ByteString>): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    adoptAppLayRecs(value: capnp.Orphan<capnp.List<AppLayRec>>): void { __S.adopt(value, __S.getPointer(1, this)); }
+    disownAppLayRecs(): capnp.Orphan<capnp.List<AppLayRec>> { return __S.disown(this.getAppLayRecs()); }
+    getAppLayRecs(): capnp.List<AppLayRec> { return __S.getList(1, AppLayLedger._AppLayRecs, this); }
+    hasAppLayRecs(): boolean { return !__S.isNull(__S.getPointer(1, this)); }
+    initAppLayRecs(length: number): capnp.List<AppLayRec> { return __S.initList(1, AppLayLedger._AppLayRecs, length, this); }
+    setAppLayRecs(value: capnp.List<AppLayRec>): void { __S.copyFrom(value, __S.getPointer(1, this)); }
+    toString(): string { return "AppLayLedger_" + super.toString(); }
+}
+AppLayLedger._TokenNames = capnp.CompositeList(ByteString);
+AppLayLedger._AppLayRecs = capnp.CompositeList(AppLayRec);

package/src/capnp/appLayRec.capnp.ts

@@ -0,0 +1,159 @@
+/* tslint:disable */
+
+/**
+ * This file has been automatically generated by the [capnpc-ts utility](https://github.com/jdiaz5513/capnp-ts).
+ */
+
+import * as capnp from "capnp-ts";
+import { ObjectSize as __O, Struct as __S } from 'capnp-ts';
+import { MetadataEntry, AttestationSubgroupData, AttestationSubgroup } from "./payload.capnp";
+export const _capnpFileId = "9ec3746dd61302cf";
+export class AppCounterpartyRec extends __S {
+    static readonly _capnp = { displayName: "AppCounterpartyRec", id: "af4fb7d47ed69ca8", size: new __O(0, 1) };
+    static _AttestationSubgroups: capnp.ListCtor<AttestationSubgroup>;
+    adoptAttestationSubgroups(value: capnp.Orphan<capnp.List<AttestationSubgroup>>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownAttestationSubgroups(): capnp.Orphan<capnp.List<AttestationSubgroup>> { return __S.disown(this.getAttestationSubgroups()); }
+    getAttestationSubgroups(): capnp.List<AttestationSubgroup> { return __S.getList(0, AppCounterpartyRec._AttestationSubgroups, this); }
+    hasAttestationSubgroups(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initAttestationSubgroups(length: number): capnp.List<AttestationSubgroup> { return __S.initList(0, AppCounterpartyRec._AttestationSubgroups, length, this); }
+    setAttestationSubgroups(value: capnp.List<AttestationSubgroup>): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    toString(): string { return "AppCounterpartyRec_" + super.toString(); }
+}
+export class AppDceRec extends __S {
+    static readonly _capnp = { displayName: "AppDceRec", id: "bf9343b8032d56c5", size: new __O(0, 1) };
+    static _AttestationSubgroups: capnp.ListCtor<AttestationSubgroup>;
+    adoptAttestationSubgroups(value: capnp.Orphan<capnp.List<AttestationSubgroup>>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownAttestationSubgroups(): capnp.Orphan<capnp.List<AttestationSubgroup>> { return __S.disown(this.getAttestationSubgroups()); }
+    getAttestationSubgroups(): capnp.List<AttestationSubgroup> { return __S.getList(0, AppDceRec._AttestationSubgroups, this); }
+    hasAttestationSubgroups(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initAttestationSubgroups(length: number): capnp.List<AttestationSubgroup> { return __S.initList(0, AppDceRec._AttestationSubgroups, length, this); }
+    setAttestationSubgroups(value: capnp.List<AttestationSubgroup>): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    toString(): string { return "AppDceRec_" + super.toString(); }
+}
+export class AppNftRec extends __S {
+    static readonly _capnp = { displayName: "AppNftRec", id: "fbc6ff8babb8c50a", size: new __O(0, 1) };
+    adoptAttestationSubgroup(value: capnp.Orphan<AttestationSubgroup>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownAttestationSubgroup(): capnp.Orphan<AttestationSubgroup> { return __S.disown(this.getAttestationSubgroup()); }
+    getAttestationSubgroup(): AttestationSubgroup { return __S.getStruct(0, AttestationSubgroup, this); }
+    hasAttestationSubgroup(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initAttestationSubgroup(): AttestationSubgroup { return __S.initStructAt(0, AttestationSubgroup, this); }
+    setAttestationSubgroup(value: AttestationSubgroup): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    toString(): string { return "AppNftRec_" + super.toString(); }
+}
+export class AppStackableRec extends __S {
+    static readonly _capnp = { displayName: "AppStackableRec", id: "cdd062ed7d86209c", size: new __O(0, 1) };
+    static _AttestationSubgroups: capnp.ListCtor<AttestationSubgroup>;
+    adoptAttestationSubgroups(value: capnp.Orphan<capnp.List<AttestationSubgroup>>): void { __S.adopt(value, __S.getPointer(0, this)); }
+    disownAttestationSubgroups(): capnp.Orphan<capnp.List<AttestationSubgroup>> { return __S.disown(this.getAttestationSubgroups()); }
+    getAttestationSubgroups(): capnp.List<AttestationSubgroup> { return __S.getList(0, AppStackableRec._AttestationSubgroups, this); }
+    hasAttestationSubgroups(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initAttestationSubgroups(length: number): capnp.List<AttestationSubgroup> { return __S.initList(0, AppStackableRec._AttestationSubgroups, length, this); }
+    setAttestationSubgroups(value: capnp.List<AttestationSubgroup>): void { __S.copyFrom(value, __S.getPointer(0, this)); }
+    toString(): string { return "AppStackableRec_" + super.toString(); }
+}
+export enum AppLayRec_RecType_Which {
+    COUNTERPARTY = 0,
+    DCE = 1,
+    NFT = 2,
+    STACKABLE = 3
+}
+export class AppLayRec_RecType extends __S {
+    static readonly COUNTERPARTY = AppLayRec_RecType_Which.COUNTERPARTY;
+    static readonly DCE = AppLayRec_RecType_Which.DCE;
+    static readonly NFT = AppLayRec_RecType_Which.NFT;
+    static readonly STACKABLE = AppLayRec_RecType_Which.STACKABLE;
+    static readonly _capnp = { displayName: "recType", id: "b322cc20c9120cdb", size: new __O(8, 2) };
+    adoptCounterparty(value: capnp.Orphan<AppCounterpartyRec>): void {
+        __S.setUint16(0, 0, this);
+        __S.adopt(value, __S.getPointer(0, this));
+    }
+    disownCounterparty(): capnp.Orphan<AppCounterpartyRec> { return __S.disown(this.getCounterparty()); }
+    getCounterparty(): AppCounterpartyRec {
+        __S.testWhich("counterparty", __S.getUint16(0, this), 0, this);
+        return __S.getStruct(0, AppCounterpartyRec, this);
+    }
+    hasCounterparty(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initCounterparty(): AppCounterpartyRec {
+        __S.setUint16(0, 0, this);
+        return __S.initStructAt(0, AppCounterpartyRec, this);
+    }
+    isCounterparty(): boolean { return __S.getUint16(0, this) === 0; }
+    setCounterparty(value: AppCounterpartyRec): void {
+        __S.setUint16(0, 0, this);
+        __S.copyFrom(value, __S.getPointer(0, this));
+    }
+    adoptDce(value: capnp.Orphan<AppDceRec>): void {
+        __S.setUint16(0, 1, this);
+        __S.adopt(value, __S.getPointer(0, this));
+    }
+    disownDce(): capnp.Orphan<AppDceRec> { return __S.disown(this.getDce()); }
+    getDce(): AppDceRec {
+        __S.testWhich("dce", __S.getUint16(0, this), 1, this);
+        return __S.getStruct(0, AppDceRec, this);
+    }
+    hasDce(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initDce(): AppDceRec {
+        __S.setUint16(0, 1, this);
+        return __S.initStructAt(0, AppDceRec, this);
+    }
+    isDce(): boolean { return __S.getUint16(0, this) === 1; }
+    setDce(value: AppDceRec): void {
+        __S.setUint16(0, 1, this);
+        __S.copyFrom(value, __S.getPointer(0, this));
+    }
+    adoptNft(value: capnp.Orphan<AppNftRec>): void {
+        __S.setUint16(0, 2, this);
+        __S.adopt(value, __S.getPointer(0, this));
+    }
+    disownNft(): capnp.Orphan<AppNftRec> { return __S.disown(this.getNft()); }
+    getNft(): AppNftRec {
+        __S.testWhich("nft", __S.getUint16(0, this), 2, this);
+        return __S.getStruct(0, AppNftRec, this);
+    }
+    hasNft(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initNft(): AppNftRec {
+        __S.setUint16(0, 2, this);
+        return __S.initStructAt(0, AppNftRec, this);
+    }
+    isNft(): boolean { return __S.getUint16(0, this) === 2; }
+    setNft(value: AppNftRec): void {
+        __S.setUint16(0, 2, this);
+        __S.copyFrom(value, __S.getPointer(0, this));
+    }
+    adoptStackable(value: capnp.Orphan<AppStackableRec>): void {
+        __S.setUint16(0, 3, this);
+        __S.adopt(value, __S.getPointer(0, this));
+    }
+    disownStackable(): capnp.Orphan<AppStackableRec> { return __S.disown(this.getStackable()); }
+    getStackable(): AppStackableRec {
+        __S.testWhich("stackable", __S.getUint16(0, this), 3, this);
+        return __S.getStruct(0, AppStackableRec, this);
+    }
+    hasStackable(): boolean { return !__S.isNull(__S.getPointer(0, this)); }
+    initStackable(): AppStackableRec {
+        __S.setUint16(0, 3, this);
+        return __S.initStructAt(0, AppStackableRec, this);
+    }
+    isStackable(): boolean { return __S.getUint16(0, this) === 3; }
+    setStackable(value: AppStackableRec): void {
+        __S.setUint16(0, 3, this);
+        __S.copyFrom(value, __S.getPointer(0, this));
+    }
+    toString(): string { return "AppLayRec_RecType_" + super.toString(); }
+    which(): AppLayRec_RecType_Which { return __S.getUint16(0, this); }
+}
+export class AppLayRec extends __S {
+    static readonly _capnp = { displayName: "AppLayRec", id: "ea6a5049023b7473", size: new __O(8, 2) };
+    getRecType(): AppLayRec_RecType { return __S.getAs(AppLayRec_RecType, this); }
+    initRecType(): AppLayRec_RecType { return __S.getAs(AppLayRec_RecType, this); }
+    adoptAcctNumApp(value: capnp.Orphan<capnp.Data>): void { __S.adopt(value, __S.getPointer(1, this)); }
+    disownAcctNumApp(): capnp.Orphan<capnp.Data> { return __S.disown(this.getAcctNumApp()); }
+    getAcctNumApp(): capnp.Data { return __S.getData(1, this); }
+    hasAcctNumApp(): boolean { return !__S.isNull(__S.getPointer(1, this)); }
+    initAcctNumApp(length: number): capnp.Data { return __S.initData(1, length, this); }
+    setAcctNumApp(value: capnp.Data): void { __S.copyFrom(value, __S.getPointer(1, this)); }
+    toString(): string { return "AppLayRec_" + super.toString(); }
+}
+AppCounterpartyRec._AttestationSubgroups = capnp.CompositeList(AttestationSubgroup);
+AppDceRec._AttestationSubgroups = capnp.CompositeList(AttestationSubgroup);
+AppStackableRec._AttestationSubgroups = capnp.CompositeList(AttestationSubgroup);