@quantovainc/qcore 0.4.3 → 0.5.1

package/README.md

@@ -105,7 +105,7 @@ Quantova shares no wire, no address, and no unit with any other chain, and QCore
 const { generateSeed, core } = require('@quantovainc/qcore');
 
 const seed = generateSeed();                 // thirty two random bytes in a Uint8Array from the platform source
-const phrase = core.mnemonicFromSeed(seed);  // the only backup, shown once and kept on the device
+const phrase = core.mnemonicFromSeed(seed);  // the only backup as UTF-8 bytes in a Uint8Array you can wipe
 ```
 
 `core.seedFromMnemonic(phrase)` restores the seed from the twenty five words as a Uint8Array. It ignores
@@ -116,10 +116,24 @@ wallet is refused with its own error, since a Quantova phrase carries a SHA3 che
 from it.
 
 Every seed is a Uint8Array. Call `seed.fill(0)` when you are done with it, and never print or log any part of
-it. The WASM core wipes its own copies of a seed before it frees them.
+it. The WASM core wipes its own copies of a seed before it frees them. The phrase comes back as a Uint8Array
+of UTF-8 text for the same reason, so call `phrase.fill(0)` once it has been shown, and pass it back to
+`core.seedFromMnemonic` as the same bytes. `core.mnemonicFromSeedText(seed)` returns the words as a string for
+a caller that must display them, and a JavaScript string can never be wiped, so prefer the bytes.
 
 ## Using it
 
+The Client checks every number the gateway reports before it signs. A fee or balance must be a string of
+the ASCII digits zero to nine, a nonce or head height must be a JSON integer, and the head is bounded by the
+time since the genesis of the named network, a constant the Client reads from the compiled core so all three
+QCore clients share one value. The Client keeps a signing session in memory. A nonce it signed once is not
+signed again until you pass that nonce as the expected nonce, which is how you say the first transaction never
+landed, and a gateway that rejects a transaction and then reports a later nonce is refused for the same reason.
+An order nonce the gateway raises above the one the session tracked needs the expected order nonce as well.
+Pass `addressBook`, a list of Q1 addresses you trust, in the Client options, and the Client refuses to sign for
+a target that shares two or more leading and trailing characters with a known address, eight in all, but is a
+different address. The sending accounts and every target signed for in the session are known as well.
+
 The last argument to a Client signing call, transfer, register, call, or callSignedOrder, is a fee
 ceiling, the most you are ever willing to pay in fees for one transaction. You choose it yourself, as a
 fixed number your app decides on its own, before you sign. The Client reads the gateway's reported fee,

package/index.d.ts

@@ -14,11 +14,14 @@ export interface SignedOrder {
   public_key: string;
   signer: string;
   nonce: number;
+  expiry: number;
 }
 
 export interface OrderLayout {
   schemeOff: number | bigint;
   ptrOff: number | bigint;
+  expiryOff: number | bigint;
+  expiry: number | bigint;
   fieldOffs?: ReadonlyArray<number | bigint>;
   regionOff?: number | bigint;
 }
@@ -32,6 +35,8 @@ export interface SignedOrderField {
 export interface SignedOrderSpec {
   schemeOff: number | bigint;
   ptrOff: number | bigint;
+  expiryOff: number | bigint;
+  expiry: number | bigint;
   regionOff?: number | bigint;
   fields: ReadonlyArray<SignedOrderField>;
 }
@@ -59,12 +64,14 @@ export interface QCore {
     selector_hex: string,
     scheme_off: WholeNumber,
     ptr_off: WholeNumber,
+    expiry_off: WholeNumber,
     field_offs_csv: string,
     fields_csv: string,
     region_off: WholeNumber,
     owner_seed: Uint8Array,
     owner_index: WholeNumber,
     nonce: WholeNumber,
+    expiry: WholeNumber,
   ): string;
   buildTypedOrderCall(
     chain_id: WholeNumber,
@@ -72,11 +79,13 @@ export interface QCore {
     selector_hex: string,
     scheme_off: WholeNumber,
     ptr_off: WholeNumber,
+    expiry_off: WholeNumber,
     region_off: WholeNumber,
     fields_json: string,
     owner_seed: Uint8Array,
     owner_index: WholeNumber,
     nonce: WholeNumber,
+    expiry: WholeNumber,
   ): string;
   checkValidUntil(valid_until: WholeNumber, head: WholeNumber): void;
   contractAddress(deployer: string, nonce: WholeNumber): string | undefined;
@@ -86,7 +95,8 @@ export interface QCore {
   mainnetChainId(): bigint;
   mapAddrWordKey(map_domain_tag: WholeNumber, key32_hex: string, word: WholeNumber): string;
   mapSlotKey(map_domain_tag: WholeNumber, key_address_hex: string): string;
-  mnemonicFromSeed(seed: Uint8Array): string;
+  mnemonicFromSeed(seed: Uint8Array): Uint8Array;
+  mnemonicFromSeedText(seed: Uint8Array): string;
   nonceSlotKey(signer_hex: string): string;
   orderSigner(seed: Uint8Array, index: WholeNumber): string;
   parseEvents(response: string): string;
@@ -97,7 +107,22 @@ export interface QCore {
   unpackSymbol(word: WholeNumber): string;
   assetBalanceBody(issuer: string, holder: string): string;
   assetSupplyBody(issuer: string): string;
-  seedFromMnemonic(phrase: string): Uint8Array;
+  seedFromMnemonic(phrase: string | Uint8Array): Uint8Array;
+  seedFromMnemonicBytes(phrase: Uint8Array): Uint8Array;
+  genesisSecs(chain_name: string): bigint;
+  headCeiling(chain_name: string, wall_secs: WholeNumber): bigint;
+  boundedValidUntil(
+    chain_name: string,
+    head: WholeNumber,
+    wall_secs: WholeNumber,
+    floor: WholeNumber | undefined,
+    floor_age_secs: WholeNumber,
+  ): bigint;
+  checkGatewayJson(response: string): void;
+  testnetRpcUrl(): string;
+  testnetChainName(): string;
+  validityBlocks(): bigint;
+  SigningSession: new (book: string[]) => SigningSession;
   signPayableCall(
     seed: Uint8Array,
     index: WholeNumber,
@@ -167,6 +192,17 @@ export interface QCore {
   vmDeployAddress(): string;
 }
 
+export interface SigningSession {
+  rememberAddress(address: string): void;
+  checkTarget(address: string): void;
+  slot(key: string, reported: bigint, expected: bigint | undefined, order: boolean): bigint;
+  signed(key: string, slot: bigint): void;
+  outcome(key: string, slot: bigint, accepted: boolean): void;
+  nextNonce(key: string): bigint | undefined;
+  isHeld(key: string, slot: bigint): boolean;
+  free(): void;
+}
+
 export class Network {
   readonly name: string;
   readonly chainId: string | null;
@@ -184,6 +220,7 @@ export interface ClientOptions {
   acknowledgeMainnet?: boolean;
   network?: Network;
   expectedChainId?: string;
+  addressBook?: ReadonlyArray<string>;
 }
 
 export class Client {
@@ -245,6 +282,8 @@ export class Client {
   ): Promise<TransferResult>;
   contractNonce(contract: string, signerHex: string): Promise<bigint>;
   contractScalar(contract: string, slot: number | bigint): Promise<bigint>;
+  contractMap(contract: string, mapDomainTag: number | bigint, keyHex: string): Promise<bigint>;
+  assetBalance(issuer: string, holder: string): Promise<bigint>;
   callSignedOrder(
     callerSeed: Uint8Array,
     callerIndex: number,
@@ -264,6 +303,6 @@ export const core: QCore;
 
 export function generateSeed(): Uint8Array;
 
-export function validUntil(nodeInfo: { head_height?: number | string | bigint }): bigint;
+export function validUntil(nodeInfo: { head_height?: number | bigint }): bigint;
 
 export function vmCallFee(transferFee: WholeNumber, meterLimit: WholeNumber): bigint;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantovainc/qcore",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "description": "Quantova's post quantum client core for JavaScript. Signs with ML-DSA-65 and builds Q1 addresses.",
   "scripts": {
     "build": "bash scripts/build.sh",

package/pkg/README.md

@@ -105,7 +105,7 @@ Quantova shares no wire, no address, and no unit with any other chain, and QCore
 const { generateSeed, core } = require('@quantovainc/qcore');
 
 const seed = generateSeed();                 // thirty two random bytes in a Uint8Array from the platform source
-const phrase = core.mnemonicFromSeed(seed);  // the only backup, shown once and kept on the device
+const phrase = core.mnemonicFromSeed(seed);  // the only backup as UTF-8 bytes in a Uint8Array you can wipe
 ```
 
 `core.seedFromMnemonic(phrase)` restores the seed from the twenty five words as a Uint8Array. It ignores
@@ -116,10 +116,24 @@ wallet is refused with its own error, since a Quantova phrase carries a SHA3 che
 from it.
 
 Every seed is a Uint8Array. Call `seed.fill(0)` when you are done with it, and never print or log any part of
-it. The WASM core wipes its own copies of a seed before it frees them.
+it. The WASM core wipes its own copies of a seed before it frees them. The phrase comes back as a Uint8Array
+of UTF-8 text for the same reason, so call `phrase.fill(0)` once it has been shown, and pass it back to
+`core.seedFromMnemonic` as the same bytes. `core.mnemonicFromSeedText(seed)` returns the words as a string for
+a caller that must display them, and a JavaScript string can never be wiped, so prefer the bytes.
 
 ## Using it
 
+The Client checks every number the gateway reports before it signs. A fee or balance must be a string of
+the ASCII digits zero to nine, a nonce or head height must be a JSON integer, and the head is bounded by the
+time since the genesis of the named network, a constant the Client reads from the compiled core so all three
+QCore clients share one value. The Client keeps a signing session in memory. A nonce it signed once is not
+signed again until you pass that nonce as the expected nonce, which is how you say the first transaction never
+landed, and a gateway that rejects a transaction and then reports a later nonce is refused for the same reason.
+An order nonce the gateway raises above the one the session tracked needs the expected order nonce as well.
+Pass `addressBook`, a list of Q1 addresses you trust, in the Client options, and the Client refuses to sign for
+a target that shares two or more leading and trailing characters with a known address, eight in all, but is a
+different address. The sending accounts and every target signed for in the session are known as well.
+
 The last argument to a Client signing call, transfer, register, call, or callSignedOrder, is a fee
 ceiling, the most you are ever willing to pay in fees for one transaction. You choose it yourself, as a
 fixed number your app decides on its own, before you sign. The Client reads the gateway's reported fee,

package/pkg/package.json

@@ -2,7 +2,7 @@
   "name": "qcore-js",
   "type": "module",
   "description": "The JavaScript binding for the Quantova client core, generated over QCore with wasm-bindgen. The core does the key derivation, the post quantum signing, and the wire, the page does the fetch.",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "license": "Apache-2.0 OR MIT",
   "repository": {
     "type": "git",

package/pkg/qcore_js.d.ts

@@ -1,6 +1,19 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class SigningSession {
+    free(): void;
+    [Symbol.dispose](): void;
+    checkTarget(address: string): void;
+    isHeld(key: string, slot: bigint): boolean;
+    constructor(book: string[]);
+    nextNonce(key: string): bigint | undefined;
+    outcome(key: string, slot: bigint, accepted: boolean): void;
+    rememberAddress(address: string): void;
+    signed(key: string, slot: bigint): void;
+    slot(key: string, reported: bigint, expected: bigint | null | undefined, order: boolean): bigint;
+}
+
 export function account_body(address: string): string;
 
 export function address(seed_bytes: Uint8Array, index: bigint): string;
@@ -11,18 +24,26 @@ export function assetSupplyBody(issuer: string): string;
 
 export function block_by_height_body(height: bigint): string;
 
-export function buildSignedOrderCall(chain_id: bigint, contract: string, selector_hex: string, scheme_off: bigint, ptr_off: bigint, field_offs_csv: string, fields_csv: string, region_off: bigint, owner_seed_bytes: Uint8Array, owner_index: bigint, nonce: bigint): string;
+export function boundedValidUntil(chain_name: string, head: bigint, wall_secs: bigint, floor: bigint | null | undefined, floor_age_secs: bigint): bigint;
+
+export function buildSignedOrderCall(chain_id: bigint, contract: string, selector_hex: string, scheme_off: bigint, ptr_off: bigint, expiry_off: bigint, field_offs_csv: string, fields_csv: string, region_off: bigint, owner_seed_bytes: Uint8Array, owner_index: bigint, nonce: bigint, expiry: bigint): string;
 
-export function buildTypedOrderCall(chain_id: bigint, contract: string, selector_hex: string, scheme_off: bigint, ptr_off: bigint, region_off: bigint, fields_json: string, owner_seed_bytes: Uint8Array, owner_index: bigint, nonce: bigint): string;
+export function buildTypedOrderCall(chain_id: bigint, contract: string, selector_hex: string, scheme_off: bigint, ptr_off: bigint, expiry_off: bigint, region_off: bigint, fields_json: string, owner_seed_bytes: Uint8Array, owner_index: bigint, nonce: bigint, expiry: bigint): string;
 
 export function chainIdFromName(name: string): bigint;
 
+export function checkGatewayJson(response: string): void;
+
 export function checkValidUntil(valid_until: bigint, head: bigint): void;
 
 export function contractAddress(deployer: string, nonce: bigint): string | undefined;
 
 export function eventsBody(height: bigint): string;
 
+export function genesisSecs(chain_name: string): bigint;
+
+export function headCeiling(chain_name: string, wall_secs: bigint): bigint;
+
 export function localChainId(): bigint;
 
 export function lookalikeOf(candidate: string, known: string[]): string | undefined;
@@ -33,7 +54,9 @@ export function mapAddrWordKey(map_domain_tag: bigint, key32_hex: string, word:
 
 export function mapSlotKey(map_domain_tag: bigint, key_address_hex: string): string;
 
-export function mnemonicFromSeed(seed_bytes: Uint8Array): any;
+export function mnemonicFromSeed(seed_bytes: Uint8Array): Uint8Array;
+
+export function mnemonicFromSeedText(seed_bytes: Uint8Array): any;
 
 export function nameKey(label: string): string;
 
@@ -51,6 +74,8 @@ export function scalarSlotKey(slot: bigint): string;
 
 export function seedFromMnemonic(phrase: string): Uint8Array;
 
+export function seedFromMnemonicBytes(phrase: Uint8Array): Uint8Array;
+
 export function signAssetCall(seed_bytes: Uint8Array, index: bigint, target: string, args_hex: string, asset_issuer: string, amount: string, nonce: bigint, meter_limit: bigint, fee: string, chain_id: bigint, valid_until: bigint, transfer_fee?: string | null): string;
 
 export function signPayableCall(seed_bytes: Uint8Array, index: bigint, target: string, args_hex: string, nonce: bigint, meter_limit: bigint, fee: string, value: string, chain_id: bigint, valid_until: bigint, transfer_fee?: string | null): string;
@@ -69,6 +94,10 @@ export function submit_body(tx_hex: string): string;
 
 export function testnetChainId(): bigint;
 
+export function testnetChainName(): string;
+
+export function testnetRpcUrl(): string;
+
 export function tokenDecimalsSlot(): bigint;
 
 export function tokenSymbolSlot(): bigint;
@@ -79,6 +108,8 @@ export function unpackSymbol(word: bigint): string;
 
 export function valid_address(address: string): boolean;
 
+export function validityBlocks(): bigint;
+
 export function vmCallFee(transfer_fee: string, meter_limit: bigint): string;
 
 export function vmDeployAddress(): string;

package/pkg/qcore_js.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./qcore_js_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    account_body, address, assetBalanceBody, assetSupplyBody, block_by_height_body, buildSignedOrderCall, buildTypedOrderCall, chainIdFromName, checkValidUntil, contractAddress, eventsBody, localChainId, lookalikeOf, mainnetChainId, mapAddrWordKey, mapSlotKey, mnemonicFromSeed, nameKey, nonceSlotKey, orderSigner, packSymbol, parseEvents, sameAddress, scalarSlotKey, seedFromMnemonic, signAssetCall, signPayableCall, signRegister, sign_call, sign_transfer, storageBody, storageValue, submit_body, testnetChainId, tokenDecimalsSlot, tokenSymbolSlot, transaction_body, unpackSymbol, valid_address, vmCallFee, vmDeployAddress
+    SigningSession, account_body, address, assetBalanceBody, assetSupplyBody, block_by_height_body, boundedValidUntil, buildSignedOrderCall, buildTypedOrderCall, chainIdFromName, checkGatewayJson, checkValidUntil, contractAddress, eventsBody, genesisSecs, headCeiling, localChainId, lookalikeOf, mainnetChainId, mapAddrWordKey, mapSlotKey, mnemonicFromSeed, mnemonicFromSeedText, nameKey, nonceSlotKey, orderSigner, packSymbol, parseEvents, sameAddress, scalarSlotKey, seedFromMnemonic, seedFromMnemonicBytes, signAssetCall, signPayableCall, signRegister, sign_call, sign_transfer, storageBody, storageValue, submit_body, testnetChainId, testnetChainName, testnetRpcUrl, tokenDecimalsSlot, tokenSymbolSlot, transaction_body, unpackSymbol, valid_address, validityBlocks, vmCallFee, vmDeployAddress
 } from "./qcore_js_bg.js";

package/pkg/qcore_js_bg.js

@@ -1,3 +1,106 @@
+export class SigningSession {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SigningSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signingsession_free(ptr, 0);
+    }
+    /**
+     * @param {string} address
+     */
+    checkTarget(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signingsession_checkTarget(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} key
+     * @param {bigint} slot
+     * @returns {boolean}
+     */
+    isHeld(key, slot) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signingsession_isHeld(this.__wbg_ptr, ptr0, len0, slot);
+        return ret !== 0;
+    }
+    /**
+     * @param {string[]} book
+     */
+    constructor(book) {
+        const ptr0 = passArrayJsValueToWasm0(book, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signingsession_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        SigningSessionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} key
+     * @returns {bigint | undefined}
+     */
+    nextNonce(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signingsession_nextNonce(this.__wbg_ptr, ptr0, len0);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @param {string} key
+     * @param {bigint} slot
+     * @param {boolean} accepted
+     */
+    outcome(key, slot, accepted) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.signingsession_outcome(this.__wbg_ptr, ptr0, len0, slot, accepted);
+    }
+    /**
+     * @param {string} address
+     */
+    rememberAddress(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.signingsession_rememberAddress(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} key
+     * @param {bigint} slot
+     */
+    signed(key, slot) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.signingsession_signed(this.__wbg_ptr, ptr0, len0, slot);
+    }
+    /**
+     * @param {string} key
+     * @param {bigint} reported
+     * @param {bigint | null | undefined} expected
+     * @param {boolean} order
+     * @returns {bigint}
+     */
+    slot(key, reported, expected, order) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signingsession_slot(this.__wbg_ptr, ptr0, len0, reported, !isLikeNone(expected), isLikeNone(expected) ? BigInt(0) : expected, order);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BigInt.asUintN(64, ret[0]);
+    }
+}
+if (Symbol.dispose) SigningSession.prototype[Symbol.dispose] = SigningSession.prototype.free;
+
 /**
  * @param {string} address
  * @returns {string}
@@ -101,21 +204,41 @@ export function block_by_height_body(height) {
     }
 }
 
+/**
+ * @param {string} chain_name
+ * @param {bigint} head
+ * @param {bigint} wall_secs
+ * @param {bigint | null | undefined} floor
+ * @param {bigint} floor_age_secs
+ * @returns {bigint}
+ */
+export function boundedValidUntil(chain_name, head, wall_secs, floor, floor_age_secs) {
+    const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.boundedValidUntil(ptr0, len0, head, wall_secs, !isLikeNone(floor), isLikeNone(floor) ? BigInt(0) : floor, floor_age_secs);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BigInt.asUintN(64, ret[0]);
+}
+
 /**
  * @param {bigint} chain_id
  * @param {string} contract
  * @param {string} selector_hex
  * @param {bigint} scheme_off
  * @param {bigint} ptr_off
+ * @param {bigint} expiry_off
  * @param {string} field_offs_csv
  * @param {string} fields_csv
  * @param {bigint} region_off
  * @param {Uint8Array} owner_seed_bytes
  * @param {bigint} owner_index
  * @param {bigint} nonce
+ * @param {bigint} expiry
  * @returns {string}
  */
-export function buildSignedOrderCall(chain_id, contract, selector_hex, scheme_off, ptr_off, field_offs_csv, fields_csv, region_off, owner_seed_bytes, owner_index, nonce) {
+export function buildSignedOrderCall(chain_id, contract, selector_hex, scheme_off, ptr_off, expiry_off, field_offs_csv, fields_csv, region_off, owner_seed_bytes, owner_index, nonce, expiry) {
     let deferred7_0;
     let deferred7_1;
     try {
@@ -129,7 +252,7 @@ export function buildSignedOrderCall(chain_id, contract, selector_hex, scheme_of
         const len3 = WASM_VECTOR_LEN;
         const ptr4 = passArray8ToWasm0(owner_seed_bytes, wasm.__wbindgen_malloc);
         const len4 = WASM_VECTOR_LEN;
-        const ret = wasm.buildSignedOrderCall(chain_id, ptr0, len0, ptr1, len1, scheme_off, ptr_off, ptr2, len2, ptr3, len3, region_off, ptr4, len4, owner_index, nonce);
+        const ret = wasm.buildSignedOrderCall(chain_id, ptr0, len0, ptr1, len1, scheme_off, ptr_off, expiry_off, ptr2, len2, ptr3, len3, region_off, ptr4, len4, owner_index, nonce, expiry);
         var ptr6 = ret[0];
         var len6 = ret[1];
         if (ret[3]) {
@@ -150,14 +273,16 @@ export function buildSignedOrderCall(chain_id, contract, selector_hex, scheme_of
  * @param {string} selector_hex
  * @param {bigint} scheme_off
  * @param {bigint} ptr_off
+ * @param {bigint} expiry_off
  * @param {bigint} region_off
  * @param {string} fields_json
  * @param {Uint8Array} owner_seed_bytes
  * @param {bigint} owner_index
  * @param {bigint} nonce
+ * @param {bigint} expiry
  * @returns {string}
  */
-export function buildTypedOrderCall(chain_id, contract, selector_hex, scheme_off, ptr_off, region_off, fields_json, owner_seed_bytes, owner_index, nonce) {
+export function buildTypedOrderCall(chain_id, contract, selector_hex, scheme_off, ptr_off, expiry_off, region_off, fields_json, owner_seed_bytes, owner_index, nonce, expiry) {
     let deferred6_0;
     let deferred6_1;
     try {
@@ -169,7 +294,7 @@ export function buildTypedOrderCall(chain_id, contract, selector_hex, scheme_off
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passArray8ToWasm0(owner_seed_bytes, wasm.__wbindgen_malloc);
         const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.buildTypedOrderCall(chain_id, ptr0, len0, ptr1, len1, scheme_off, ptr_off, region_off, ptr2, len2, ptr3, len3, owner_index, nonce);
+        const ret = wasm.buildTypedOrderCall(chain_id, ptr0, len0, ptr1, len1, scheme_off, ptr_off, expiry_off, region_off, ptr2, len2, ptr3, len3, owner_index, nonce, expiry);
         var ptr5 = ret[0];
         var len5 = ret[1];
         if (ret[3]) {
@@ -195,6 +320,18 @@ export function chainIdFromName(name) {
     return BigInt.asUintN(64, ret);
 }
 
+/**
+ * @param {string} response
+ */
+export function checkGatewayJson(response) {
+    const ptr0 = passStringToWasm0(response, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.checkGatewayJson(ptr0, len0);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
 /**
  * @param {bigint} valid_until
  * @param {bigint} head
@@ -240,6 +377,29 @@ export function eventsBody(height) {
     }
 }
 
+/**
+ * @param {string} chain_name
+ * @returns {bigint}
+ */
+export function genesisSecs(chain_name) {
+    const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.genesisSecs(ptr0, len0);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {string} chain_name
+ * @param {bigint} wall_secs
+ * @returns {bigint}
+ */
+export function headCeiling(chain_name, wall_secs) {
+    const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.headCeiling(ptr0, len0, wall_secs);
+    return BigInt.asUintN(64, ret);
+}
+
 /**
  * @returns {bigint}
  */
@@ -330,12 +490,28 @@ export function mapSlotKey(map_domain_tag, key_address_hex) {
 
 /**
  * @param {Uint8Array} seed_bytes
- * @returns {any}
+ * @returns {Uint8Array}
  */
 export function mnemonicFromSeed(seed_bytes) {
     const ptr0 = passArray8ToWasm0(seed_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.mnemonicFromSeed(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * @param {Uint8Array} seed_bytes
+ * @returns {any}
+ */
+export function mnemonicFromSeedText(seed_bytes) {
+    const ptr0 = passArray8ToWasm0(seed_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mnemonicFromSeedText(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -495,6 +671,22 @@ export function seedFromMnemonic(phrase) {
     return v2;
 }
 
+/**
+ * @param {Uint8Array} phrase
+ * @returns {Uint8Array}
+ */
+export function seedFromMnemonicBytes(phrase) {
+    const ptr0 = passArray8ToWasm0(phrase, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.seedFromMnemonicBytes(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
 /**
  * @param {Uint8Array} seed_bytes
  * @param {bigint} index
@@ -780,6 +972,38 @@ export function testnetChainId() {
     return BigInt.asUintN(64, ret);
 }
 
+/**
+ * @returns {string}
+ */
+export function testnetChainName() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.testnetChainName();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function testnetRpcUrl() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.testnetRpcUrl();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @returns {bigint}
  */
@@ -843,6 +1067,14 @@ export function valid_address(address) {
     return ret !== 0;
 }
 
+/**
+ * @returns {bigint}
+ */
+export function validityBlocks() {
+    const ret = wasm.validityBlocks();
+    return BigInt.asUintN(64, ret);
+}
+
 /**
  * @param {string} transfer_fee
  * @param {bigint} meter_limit
@@ -913,6 +1145,10 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
+const SigningSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signingsession_free(ptr, 1));
+
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
     wasm.__wbindgen_externrefs.set(idx, obj);