boing-sdk 0.3.0

package/dist/callAbi.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Minimal **call layout** helpers: encode Boing `ContractCall.calldata` as a reference-style
+ * **selector low byte + 32-byte words** without a foreign ABI (no keccak4, no Solidity ABI).
+ *
+ * Pair with {@link encodeBoingCall} / {@link boingWord*} from `calldata.ts` for full control.
+ * See `docs/BOING-REFERENCE-TOKEN.md` and `docs/BOING-REFERENCE-NFT.md` for protocol-defined layouts.
+ */
+import { type BoingCalldataWord } from './calldata.js';
+/** Supported 32-byte word kinds for schema-driven encoding. */
+export type BoingAbiParamKind = 'u128' | 'account' | 'bytes32' | 'bool';
+/** Structured argument before encoding to a word. */
+export type BoingAbiArg = {
+    kind: 'u128';
+    value: bigint;
+} | {
+    kind: 'account';
+    hex32: string;
+} | {
+    kind: 'bytes32';
+    hexOrBytes: string | Uint8Array;
+} | {
+    kind: 'bool';
+    value: boolean;
+};
+export declare function abiArgU128(value: bigint | number | string): BoingAbiArg;
+export declare function abiArgAccount(hex32: string): BoingAbiArg;
+export declare function abiArgBytes32(hexOrBytes: string | Uint8Array): BoingAbiArg;
+export declare function abiArgBool(value: boolean): BoingAbiArg;
+/** Map one structured arg to a 32-byte calldata word. */
+export declare function encodeBoingAbiArgToWord(arg: BoingAbiArg): BoingCalldataWord;
+/**
+ * Encode `selectorLowByte` + words from structured args (same result shape as {@link encodeBoingCall}).
+ */
+export declare function encodeBoingCallFromAbiArgs(selectorLowByte: number, args: readonly BoingAbiArg[]): Uint8Array;
+/**
+ * Encode from a simple param-kind list + runtime values (order must match).
+ */
+export declare function encodeBoingCallTyped(selectorLowByte: number, paramKinds: readonly BoingAbiParamKind[], values: readonly unknown[]): Uint8Array;
+/** Descriptor for {@link encodeBoingCallFromDescriptor}. */
+export interface BoingCallDescriptor {
+    readonly selector: number;
+    readonly params: readonly BoingAbiParamKind[];
+}
+/**
+ * Built-in layouts matching **reference** token / NFT docs (selectors + word order).
+ * Use {@link encodeBoingCallTyped} or {@link encodeBoingCallFromAbiArgs} for custom contracts.
+ */
+export declare const BoingReferenceCallDescriptors: {
+    readonly token: {
+        readonly transfer: {
+            readonly selector: 1;
+            readonly params: readonly ["account", "u128"];
+        };
+        readonly mint_first: {
+            readonly selector: 2;
+            readonly params: readonly ["account", "u128"];
+        };
+    };
+    readonly nft: {
+        readonly owner_of: {
+            readonly selector: 3;
+            readonly params: readonly ["bytes32"];
+        };
+        readonly transfer_nft: {
+            readonly selector: 4;
+            readonly params: readonly ["account", "bytes32"];
+        };
+        readonly set_metadata_hash: {
+            readonly selector: 5;
+            readonly params: readonly ["bytes32", "bytes32"];
+        };
+    };
+    /** Native constant-product pool (`docs/NATIVE-AMM-CALLDATA.md`) — three u128 words after selector. */
+    readonly nativeAmm: {
+        readonly swap: {
+            readonly selector: 16;
+            readonly params: readonly ["u128", "u128", "u128"];
+        };
+        readonly add_liquidity: {
+            readonly selector: 17;
+            readonly params: readonly ["u128", "u128", "u128"];
+        };
+        readonly remove_liquidity: {
+            readonly selector: 18;
+            readonly params: readonly ["u128", "u128", "u128"];
+        };
+        readonly remove_liquidity_to: {
+            readonly selector: 22;
+            readonly params: readonly ["u128", "u128", "u128", "account", "account"];
+        };
+    };
+    /**
+     * Native LP share token (`docs/NATIVE-LP-SHARE-TOKEN.md`) — same word layout as reference fungible
+     * for `transfer` / `mint`; `set_minter_once` is one account word.
+     */
+    readonly lpShare: {
+        readonly transfer: {
+            readonly selector: 1;
+            readonly params: readonly ["account", "u128"];
+        };
+        readonly mint: {
+            readonly selector: 6;
+            readonly params: readonly ["account", "u128"];
+        };
+        readonly set_minter_once: {
+            readonly selector: 7;
+            readonly params: readonly ["account"];
+        };
+    };
+    /** LP vault `configure` only (`docs/NATIVE-AMM-LP-VAULT.md`). Use `encodeNativeAmmLpVaultDepositAddCalldata` for `deposit_add`. */
+    readonly nativeAmmLpVault: {
+        readonly configure: {
+            readonly selector: 192;
+            readonly params: readonly ["account", "account"];
+        };
+    };
+};
+export declare function encodeBoingCallFromDescriptor(descriptor: BoingCallDescriptor, values: readonly unknown[]): Uint8Array;
+//# sourceMappingURL=callAbi.d.ts.map

package/dist/callAbi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callAbi.d.ts","sourceRoot":"","sources":["../src/callAbi.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,iBAAiB,EAKvB,MAAM,eAAe,CAAC;AAsBvB,+DAA+D;AAC/D,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAExE,qDAAqD;AACrD,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAErC,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,CAGvE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAExD;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,CAE1E;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAEtD;AAED,yDAAyD;AACzD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,WAAW,GAAG,iBAAiB,CAa3E;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,SAAS,WAAW,EAAE,GAC3B,UAAU,CAGZ;AAsBD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,UAAU,CAQZ;AAED,4DAA4D;AAC5D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC/C;AAED;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;IAyBxC,sGAAsG;;;;;;;;;;;;;;;;;;;IAmBtG;;;OAGG;;;;;;;;;;;;;;;IAeH,mIAAmI;;;;;;;CAO3H,CAAC;AAEX,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,mBAAmB,EAC/B,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,UAAU,CAEZ"}

package/dist/callAbi.js

@@ -0,0 +1,156 @@
+/**
+ * Minimal **call layout** helpers: encode Boing `ContractCall.calldata` as a reference-style
+ * **selector low byte + 32-byte words** without a foreign ABI (no keccak4, no Solidity ABI).
+ *
+ * Pair with {@link encodeBoingCall} / {@link boingWord*} from `calldata.ts` for full control.
+ * See `docs/BOING-REFERENCE-TOKEN.md` and `docs/BOING-REFERENCE-NFT.md` for protocol-defined layouts.
+ */
+import { boingWordAccount, boingWordFixed, boingWordU128, encodeBoingCall, } from './calldata.js';
+import { SELECTOR_MINT_FIRST, SELECTOR_TRANSFER } from './referenceToken.js';
+import { SELECTOR_OWNER_OF, SELECTOR_SET_METADATA_HASH, SELECTOR_TRANSFER_NFT, } from './referenceNft.js';
+import { SELECTOR_NATIVE_AMM_ADD_LIQUIDITY, SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY, SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY_TO, SELECTOR_NATIVE_AMM_SWAP, } from './nativeAmm.js';
+import { SELECTOR_NATIVE_AMM_LP_VAULT_CONFIGURE, } from './nativeAmmLpVault.js';
+import { SELECTOR_LP_SHARE_MINT, SELECTOR_LP_SHARE_SET_MINTER_ONCE, SELECTOR_LP_SHARE_TRANSFER, } from './nativeLpShareToken.js';
+export function abiArgU128(value) {
+    const v = typeof value === 'bigint' ? value : BigInt(value);
+    return { kind: 'u128', value: v };
+}
+export function abiArgAccount(hex32) {
+    return { kind: 'account', hex32 };
+}
+export function abiArgBytes32(hexOrBytes) {
+    return { kind: 'bytes32', hexOrBytes };
+}
+export function abiArgBool(value) {
+    return { kind: 'bool', value };
+}
+/** Map one structured arg to a 32-byte calldata word. */
+export function encodeBoingAbiArgToWord(arg) {
+    switch (arg.kind) {
+        case 'u128':
+            return boingWordU128(arg.value);
+        case 'account':
+            return boingWordAccount(arg.hex32);
+        case 'bytes32':
+            return boingWordFixed(arg.hexOrBytes);
+        case 'bool':
+            return boingWordU128(arg.value ? 1n : 0n);
+        default:
+            throw new Error('unhandled BoingAbiArg');
+    }
+}
+/**
+ * Encode `selectorLowByte` + words from structured args (same result shape as {@link encodeBoingCall}).
+ */
+export function encodeBoingCallFromAbiArgs(selectorLowByte, args) {
+    const words = args.map(encodeBoingAbiArgToWord);
+    return encodeBoingCall(selectorLowByte, words);
+}
+function coerceValue(kind, value) {
+    switch (kind) {
+        case 'u128':
+            return abiArgU128(value);
+        case 'account':
+            if (typeof value !== 'string')
+                throw new TypeError('account arg must be hex string');
+            return abiArgAccount(value);
+        case 'bytes32':
+            if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+                throw new TypeError('bytes32 arg must be hex string or Uint8Array');
+            }
+            return abiArgBytes32(value);
+        case 'bool':
+            if (typeof value !== 'boolean')
+                throw new TypeError('bool arg must be boolean');
+            return abiArgBool(value);
+        default:
+            throw new Error('unhandled BoingAbiParamKind');
+    }
+}
+/**
+ * Encode from a simple param-kind list + runtime values (order must match).
+ */
+export function encodeBoingCallTyped(selectorLowByte, paramKinds, values) {
+    if (paramKinds.length !== values.length) {
+        throw new Error(`encodeBoingCallTyped: expected ${paramKinds.length} values, got ${values.length}`);
+    }
+    const args = paramKinds.map((k, i) => coerceValue(k, values[i]));
+    return encodeBoingCallFromAbiArgs(selectorLowByte, args);
+}
+/**
+ * Built-in layouts matching **reference** token / NFT docs (selectors + word order).
+ * Use {@link encodeBoingCallTyped} or {@link encodeBoingCallFromAbiArgs} for custom contracts.
+ */
+export const BoingReferenceCallDescriptors = {
+    token: {
+        transfer: {
+            selector: SELECTOR_TRANSFER,
+            params: ['account', 'u128'],
+        },
+        mint_first: {
+            selector: SELECTOR_MINT_FIRST,
+            params: ['account', 'u128'],
+        },
+    },
+    nft: {
+        owner_of: {
+            selector: SELECTOR_OWNER_OF,
+            params: ['bytes32'],
+        },
+        transfer_nft: {
+            selector: SELECTOR_TRANSFER_NFT,
+            params: ['account', 'bytes32'],
+        },
+        set_metadata_hash: {
+            selector: SELECTOR_SET_METADATA_HASH,
+            params: ['bytes32', 'bytes32'],
+        },
+    },
+    /** Native constant-product pool (`docs/NATIVE-AMM-CALLDATA.md`) — three u128 words after selector. */
+    nativeAmm: {
+        swap: {
+            selector: SELECTOR_NATIVE_AMM_SWAP,
+            params: ['u128', 'u128', 'u128'],
+        },
+        add_liquidity: {
+            selector: SELECTOR_NATIVE_AMM_ADD_LIQUIDITY,
+            params: ['u128', 'u128', 'u128'],
+        },
+        remove_liquidity: {
+            selector: SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY,
+            params: ['u128', 'u128', 'u128'],
+        },
+        remove_liquidity_to: {
+            selector: SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY_TO,
+            params: ['u128', 'u128', 'u128', 'account', 'account'],
+        },
+    },
+    /**
+     * Native LP share token (`docs/NATIVE-LP-SHARE-TOKEN.md`) — same word layout as reference fungible
+     * for `transfer` / `mint`; `set_minter_once` is one account word.
+     */
+    lpShare: {
+        transfer: {
+            selector: SELECTOR_LP_SHARE_TRANSFER,
+            params: ['account', 'u128'],
+        },
+        mint: {
+            selector: SELECTOR_LP_SHARE_MINT,
+            params: ['account', 'u128'],
+        },
+        set_minter_once: {
+            selector: SELECTOR_LP_SHARE_SET_MINTER_ONCE,
+            params: ['account'],
+        },
+    },
+    /** LP vault `configure` only (`docs/NATIVE-AMM-LP-VAULT.md`). Use `encodeNativeAmmLpVaultDepositAddCalldata` for `deposit_add`. */
+    nativeAmmLpVault: {
+        configure: {
+            selector: SELECTOR_NATIVE_AMM_LP_VAULT_CONFIGURE,
+            params: ['account', 'account'],
+        },
+    },
+};
+export function encodeBoingCallFromDescriptor(descriptor, values) {
+    return encodeBoingCallTyped(descriptor.selector, descriptor.params, values);
+}

package/dist/calldata.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Generic Boing VM **calldata word** helpers (32-byte stack-word style).
+ * Reference token/NFT layouts use selector in the **last** byte of the first word; custom contracts may
+ * reuse these primitives for consistent SDK ergonomics. See `docs/BOING-REFERENCE-TOKEN.md`.
+ */
+/** Exactly 32 bytes — use {@link assertBoingCalldataWord} or `boingWord*` constructors. */
+export type BoingCalldataWord = Uint8Array & {
+    readonly __boingCalldataWord?: true;
+};
+/** Ensure `bytes` is exactly 32 bytes for use as a calldata argument word. */
+export declare function assertBoingCalldataWord(bytes: Uint8Array): BoingCalldataWord;
+/** Typed selector word (low byte only; rest zero), for {@link encodeBoingCall} argument lists. */
+export declare function boingWordSelector(lowByte: number): BoingCalldataWord;
+/** Typed u128-in-low-16-bytes word. */
+export declare function boingWordU128(value: bigint): BoingCalldataWord;
+/** Typed 32-byte account / blob word. */
+export declare function boingWordAccount(hexAccount32: string): BoingCalldataWord;
+/** Typed fixed 32-byte word from hex or bytes. */
+export declare function boingWordFixed(hexOrBytes: string | Uint8Array): BoingCalldataWord;
+/**
+ * Build calldata: first word is `selectorLowByte` in the **last** byte (reference layout), then each `args` word (32 bytes).
+ * For arbitrary trailing bytes (non–word-aligned layouts), use {@link concatCalldata} directly.
+ */
+export declare function encodeBoingCall(selectorLowByte: number, args: readonly BoingCalldataWord[]): Uint8Array;
+/** 32-byte word with single-byte selector in the low byte (reference layout). */
+export declare function calldataSelectorLastByte(selector: number): Uint8Array;
+/** 32-byte word: unsigned 128-bit value in the low 16 bytes (big-endian); high 16 bytes zero. */
+export declare function calldataU128BeWord(value: bigint): Uint8Array;
+/** 32-byte word containing a 32-byte Boing `AccountId` (or any 32-byte blob), left-aligned. */
+export declare function calldataAccountIdWord(hexAccount32: string): Uint8Array;
+/** Normalize to a 32-byte calldata word (hex string or `Uint8Array`). */
+export declare function calldataFixedWord32(hexOrBytes: string | Uint8Array): Uint8Array;
+/** Concatenate calldata segments (often 32-byte words). */
+export declare function concatCalldata(parts: Uint8Array[]): Uint8Array;
+//# sourceMappingURL=calldata.d.ts.map

package/dist/calldata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calldata.d.ts","sourceRoot":"","sources":["../src/calldata.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,2FAA2F;AAC3F,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG;IAAE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAErF,8EAA8E;AAC9E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,iBAAiB,CAK5E;AAED,kGAAkG;AAClG,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAEpE;AAED,uCAAuC;AACvC,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAE9D;AAED,yCAAyC;AACzC,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,iBAAiB,CAExE;AAED,kDAAkD;AAClD,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,iBAAiB,CAEjF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,SAAS,iBAAiB,EAAE,GACjC,UAAU,CAGZ;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAIrE;AAED,iGAAiG;AACjG,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAa5D;AAED,+FAA+F;AAC/F,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU,CAQtE;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAQ/E;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,CAU9D"}

package/dist/calldata.js

@@ -0,0 +1,93 @@
+/**
+ * Generic Boing VM **calldata word** helpers (32-byte stack-word style).
+ * Reference token/NFT layouts use selector in the **last** byte of the first word; custom contracts may
+ * reuse these primitives for consistent SDK ergonomics. See `docs/BOING-REFERENCE-TOKEN.md`.
+ */
+import { ensureHex, hexToBytes } from './hex.js';
+/** Ensure `bytes` is exactly 32 bytes for use as a calldata argument word. */
+export function assertBoingCalldataWord(bytes) {
+    if (bytes.length !== 32) {
+        throw new Error(`BoingCalldataWord must be 32 bytes, got ${bytes.length}`);
+    }
+    return bytes;
+}
+/** Typed selector word (low byte only; rest zero), for {@link encodeBoingCall} argument lists. */
+export function boingWordSelector(lowByte) {
+    return assertBoingCalldataWord(calldataSelectorLastByte(lowByte));
+}
+/** Typed u128-in-low-16-bytes word. */
+export function boingWordU128(value) {
+    return assertBoingCalldataWord(calldataU128BeWord(value));
+}
+/** Typed 32-byte account / blob word. */
+export function boingWordAccount(hexAccount32) {
+    return assertBoingCalldataWord(calldataAccountIdWord(hexAccount32));
+}
+/** Typed fixed 32-byte word from hex or bytes. */
+export function boingWordFixed(hexOrBytes) {
+    return assertBoingCalldataWord(calldataFixedWord32(hexOrBytes));
+}
+/**
+ * Build calldata: first word is `selectorLowByte` in the **last** byte (reference layout), then each `args` word (32 bytes).
+ * For arbitrary trailing bytes (non–word-aligned layouts), use {@link concatCalldata} directly.
+ */
+export function encodeBoingCall(selectorLowByte, args) {
+    const head = calldataSelectorLastByte(selectorLowByte);
+    return concatCalldata([head, ...args]);
+}
+/** 32-byte word with single-byte selector in the low byte (reference layout). */
+export function calldataSelectorLastByte(selector) {
+    const w = new Uint8Array(32);
+    w[31] = selector & 0xff;
+    return w;
+}
+/** 32-byte word: unsigned 128-bit value in the low 16 bytes (big-endian); high 16 bytes zero. */
+export function calldataU128BeWord(value) {
+    const w = new Uint8Array(32);
+    if (value < 0n || value > (1n << 128n) - 1n) {
+        throw new RangeError('value must fit in u128');
+    }
+    const be = new Uint8Array(16);
+    let x = value;
+    for (let i = 15; i >= 0; i--) {
+        be[i] = Number(x & 0xffn);
+        x >>= 8n;
+    }
+    w.set(be, 16);
+    return w;
+}
+/** 32-byte word containing a 32-byte Boing `AccountId` (or any 32-byte blob), left-aligned. */
+export function calldataAccountIdWord(hexAccount32) {
+    const b = hexToBytes(ensureHex(hexAccount32));
+    if (b.length !== 32) {
+        throw new Error('account id must be 32 bytes hex');
+    }
+    const w = new Uint8Array(32);
+    w.set(b);
+    return w;
+}
+/** Normalize to a 32-byte calldata word (hex string or `Uint8Array`). */
+export function calldataFixedWord32(hexOrBytes) {
+    if (hexOrBytes instanceof Uint8Array) {
+        if (hexOrBytes.length !== 32)
+            throw new Error('word must be 32 bytes');
+        return hexOrBytes;
+    }
+    const b = hexToBytes(ensureHex(hexOrBytes));
+    if (b.length !== 32)
+        throw new Error('word must be 32 bytes hex');
+    return b;
+}
+/** Concatenate calldata segments (often 32-byte words). */
+export function concatCalldata(parts) {
+    let n = 0;
+    for (const p of parts)
+        n += p.length;
+    const out = new Uint8Array(n);
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+}

package/dist/canonicalDeployArtifacts.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Versioning + tx-object helpers for **pinned** native Boing deploys (form-parity with EVM apps).
+ *
+ * See `docs/BOING-CANONICAL-DEPLOY-ARTIFACTS.md`. **Fungible** and **NFT collection** templates ship a
+ * pinned default in this package (`DEFAULT_REFERENCE_*`); env vars still override when set.
+ */
+import { type NativeTokenSecurityFeaturesInput } from './nativeTokenSecurity.js';
+/** Logical id for the fungible template line item (docs + telemetry). */
+export declare const REFERENCE_FUNGIBLE_TEMPLATE_ARTIFACT_ID: "boing.reference_fungible.v0";
+/** Bump when default pinned hex in this package changes. */
+export declare const REFERENCE_FUNGIBLE_TEMPLATE_VERSION: "1";
+/** Logical id for the secured fungible template (`0xFD` init + runtime toggles). */
+export declare const REFERENCE_FUNGIBLE_SECURED_TEMPLATE_ARTIFACT_ID: "boing.reference_fungible_secured.v0";
+/** Bump when default pinned secured hex in this package changes. */
+export declare const REFERENCE_FUNGIBLE_SECURED_TEMPLATE_VERSION: "1";
+/** Logical id for the NFT collection template. */
+export declare const REFERENCE_NFT_COLLECTION_TEMPLATE_ARTIFACT_ID: "boing.reference_nft_collection.v0";
+/** Matches `reference_nft_collection_template_bytecode()` in `boing-execution` (regenerate via `dump_reference_token_artifacts`). */
+export declare const REFERENCE_NFT_COLLECTION_TEMPLATE_VERSION: "1";
+/** Boing Express / wallet JSON-RPC tx object for `contract_deploy_meta`. */
+export type ContractDeployMetaTxObject = {
+    type: 'contract_deploy_meta';
+    bytecode: `0x${string}`;
+    purpose_category: string;
+    asset_name: string;
+    asset_symbol: string;
+    description_hash?: `0x${string}`;
+};
+/**
+ * Normalize hex for wallet RPC payloads (`0x` prefix). Use for deploy bytecode or `description_hash`.
+ */
+export declare function ensure0xHex(hex: string): `0x${string}`;
+/**
+ * Resolve pinned fungible template bytecode: explicit override → known env keys → embedded default
+ * (`DEFAULT_REFERENCE_FUNGIBLE_TEMPLATE_BYTECODE_HEX`).
+ */
+export declare function resolveReferenceFungibleTemplateBytecodeHex(opts?: {
+    explicitHex?: string | undefined;
+    /** Extra env var names to try after `explicitHex` (`globalThis.process.env` when present). */
+    extraEnvKeys?: readonly string[];
+}): `0x${string}`;
+/**
+ * Resolve pinned **secured** fungible deploy bytecode (`0xFD` init + runtime): explicit → env → embedded default.
+ */
+export declare function resolveReferenceFungibleSecuredTemplateBytecodeHex(opts?: {
+    explicitHex?: string | undefined;
+    extraEnvKeys?: readonly string[];
+}): `0x${string}`;
+/**
+ * Resolve pinned **reference NFT collection** template bytecode (explicit → env → embedded default,
+ * same pattern as {@link resolveReferenceFungibleTemplateBytecodeHex}).
+ */
+export declare function resolveReferenceNftCollectionTemplateBytecodeHex(opts?: {
+    explicitHex?: string | undefined;
+    extraEnvKeys?: readonly string[];
+}): `0x${string}`;
+/**
+ * Build a **`contract_deploy_meta`** object for `boing_sendTransaction` / `boing_signTransaction`.
+ */
+export declare function buildContractDeployMetaTx(input: {
+    bytecodeHex: string;
+    assetName: string;
+    assetSymbol: string;
+    /** Default `token` matches Express convenience when name/symbol are set. */
+    purposeCategory?: string;
+    descriptionHashHex?: string;
+}): ContractDeployMetaTxObject;
+export type BuildReferenceFungibleDeployMetaTxInput = {
+    assetName: string;
+    assetSymbol: string;
+    purposeCategory?: string;
+    descriptionHashHex?: string;
+    /**
+     * When set and **`descriptionHashHex`** is omitted, commits wizard security toggles into **`description_hash`**
+     * (Blake3 over canonical JSON — see {@link descriptionHashHexFromNativeTokenSecurity}).
+     */
+    nativeTokenSecurity?: NativeTokenSecurityFeaturesInput;
+    /** Override pinned template (advanced); default uses {@link resolveReferenceFungibleTemplateBytecodeHex}. */
+    bytecodeHexOverride?: string;
+    extraEnvKeys?: readonly string[];
+};
+/**
+ * **One call** for wizard-style **Deploy token** on Boing: resolve pinned fungible bytecode + build **`contract_deploy_meta`**.
+ * Pass the result to **`boing_sendTransaction`** / **`boing_signTransaction`** (Boing Express).
+ */
+export declare function buildReferenceFungibleDeployMetaTx(input: BuildReferenceFungibleDeployMetaTxInput): ContractDeployMetaTxObject;
+export type BuildReferenceFungibleSecuredDeployMetaTxInput = {
+    assetName: string;
+    assetSymbol: string;
+    purposeCategory?: string;
+    descriptionHashHex?: string;
+    nativeTokenSecurity?: NativeTokenSecurityFeaturesInput;
+    /**
+     * When `nativeTokenSecurity` is set, deploy bytecode encodes enforcement flags/limits on-chain.
+     * Provide **`chainHeight`** from `boing_chainHeight` when **`timelock`** is enabled.
+     */
+    chainContext?: {
+        chainHeight: bigint;
+    };
+    /**
+     * Initial `mint_first` supply (base units) for deriving **`maxWalletPercentage`** → `max_wallet` cap.
+     */
+    mintFirstTotalSupplyWei?: bigint;
+    bytecodeHexOverride?: string;
+    extraEnvKeys?: readonly string[];
+};
+/**
+ * Same as {@link buildReferenceFungibleDeployMetaTx} but uses the secured fungible template.
+ * When **`nativeTokenSecurity`** is passed, bytecode is built so wizard toggles map to on-chain
+ * `reference_fungible_secured` init storage (not only `description_hash`). When omitted, uses the
+ * pinned default secured template (flags off).
+ */
+export declare function buildReferenceFungibleSecuredDeployMetaTx(input: BuildReferenceFungibleSecuredDeployMetaTxInput): ContractDeployMetaTxObject;
+export type BuildReferenceNftCollectionDeployMetaTxInput = {
+    collectionName: string;
+    collectionSymbol: string;
+    purposeCategory?: string;
+    descriptionHashHex?: string;
+    bytecodeHexOverride?: string;
+    extraEnvKeys?: readonly string[];
+};
+/**
+ * **One call** for **native NFT collection** deploy meta tx. Bytecode: **`bytecodeHexOverride`** if set,
+ * else env keys (see {@link resolveReferenceNftCollectionTemplateBytecodeHex}), else the SDK embedded default.
+ */
+export declare function buildReferenceNftCollectionDeployMetaTx(input: BuildReferenceNftCollectionDeployMetaTxInput): ContractDeployMetaTxObject;
+/**
+ * Resolve **native constant-product pool** bytecode from override or env (same keys as
+ * [examples/native-boing-tutorial](../examples/native-boing-tutorial/) **`BOING_NATIVE_AMM_BYTECODE_HEX`**).
+ */
+export declare function resolveNativeConstantProductPoolBytecodeHex(opts?: {
+    explicitHex?: string | undefined;
+    extraEnvKeys?: readonly string[];
+}): `0x${string}` | undefined;
+export type BuildNativeConstantProductPoolDeployMetaTxInput = {
+    /** QA / wallet display name (default: `Native CP Pool`). */
+    poolLabel?: string;
+    /** QA / wallet symbol (default: `POOL`). */
+    poolSymbol?: string;
+    /**
+     * Mempool QA category for pool bytecode ([NATIVE-AMM-CALLDATA.md](../../docs/NATIVE-AMM-CALLDATA.md)).
+     * Default **`dapp`** matches canonical testnet pool deploys.
+     */
+    purposeCategory?: string;
+    descriptionHashHex?: string;
+    bytecodeHexOverride?: string;
+    extraEnvKeys?: readonly string[];
+};
+/**
+ * **One call** for **native CP pool** **`contract_deploy_meta`**: pinned bytecode from env or override,
+ * **`purpose_category`** default **`dapp`**, then the same Express shape as token/NFT deploys.
+ */
+export declare function buildNativeConstantProductPoolDeployMetaTx(input: BuildNativeConstantProductPoolDeployMetaTxInput): ContractDeployMetaTxObject;
+//# sourceMappingURL=canonicalDeployArtifacts.d.ts.map

package/dist/canonicalDeployArtifacts.d.ts.map

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