@quantovainc/qcore 0.4.3 → 0.5.1

package/pkg/qcore_js_bg.wasm.d.ts

@@ -1,23 +1,29 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_signingsession_free: (a: number, b: number) => void;
 export const account_body: (a: number, b: number) => [number, number];
 export const address: (a: number, b: number, c: bigint) => [number, number, number, number];
 export const assetBalanceBody: (a: number, b: number, c: number, d: number) => [number, number];
 export const assetSupplyBody: (a: number, b: number) => [number, number];
 export const block_by_height_body: (a: bigint) => [number, number];
-export const buildSignedOrderCall: (a: bigint, b: number, c: number, d: number, e: number, f: bigint, g: bigint, h: number, i: number, j: number, k: number, l: bigint, m: number, n: number, o: bigint, p: bigint) => [number, number, number, number];
-export const buildTypedOrderCall: (a: bigint, b: number, c: number, d: number, e: number, f: bigint, g: bigint, h: bigint, i: number, j: number, k: number, l: number, m: bigint, n: bigint) => [number, number, number, number];
+export const boundedValidUntil: (a: number, b: number, c: bigint, d: bigint, e: number, f: bigint, g: bigint) => [bigint, number, number];
+export const buildSignedOrderCall: (a: bigint, b: number, c: number, d: number, e: number, f: bigint, g: bigint, h: bigint, i: number, j: number, k: number, l: number, m: bigint, n: number, o: number, p: bigint, q: bigint, r: bigint) => [number, number, number, number];
+export const buildTypedOrderCall: (a: bigint, b: number, c: number, d: number, e: number, f: bigint, g: bigint, h: bigint, i: bigint, j: number, k: number, l: number, m: number, n: bigint, o: bigint, p: bigint) => [number, number, number, number];
 export const chainIdFromName: (a: number, b: number) => bigint;
+export const checkGatewayJson: (a: number, b: number) => [number, number];
 export const checkValidUntil: (a: bigint, b: bigint) => [number, number];
 export const contractAddress: (a: number, b: number, c: bigint) => [number, number];
 export const eventsBody: (a: bigint) => [number, number];
+export const genesisSecs: (a: number, b: number) => bigint;
+export const headCeiling: (a: number, b: number, c: bigint) => bigint;
 export const localChainId: () => bigint;
 export const lookalikeOf: (a: number, b: number, c: number, d: number) => [number, number];
 export const mainnetChainId: () => bigint;
 export const mapAddrWordKey: (a: bigint, b: number, c: number, d: bigint) => [number, number, number, number];
 export const mapSlotKey: (a: bigint, b: number, c: number) => [number, number, number, number];
-export const mnemonicFromSeed: (a: number, b: number) => [number, number, number];
+export const mnemonicFromSeed: (a: number, b: number) => [number, number, number, number];
+export const mnemonicFromSeedText: (a: number, b: number) => [number, number, number];
 export const nameKey: (a: number, b: number) => [number, number];
 export const nonceSlotKey: (a: number, b: number) => [number, number, number, number];
 export const orderSigner: (a: number, b: number, c: bigint) => [number, number, number, number];
@@ -26,20 +32,32 @@ export const parseEvents: (a: number, b: number) => [number, number, number, num
 export const sameAddress: (a: number, b: number, c: number, d: number) => number;
 export const scalarSlotKey: (a: bigint) => [number, number];
 export const seedFromMnemonic: (a: number, b: number) => [number, number, number, number];
+export const seedFromMnemonicBytes: (a: number, b: number) => [number, number, number, number];
 export const signAssetCall: (a: number, b: number, c: bigint, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: bigint, m: bigint, n: number, o: number, p: bigint, q: bigint, r: number, s: number) => [number, number, number, number];
 export const signPayableCall: (a: number, b: number, c: bigint, d: number, e: number, f: number, g: number, h: bigint, i: bigint, j: number, k: number, l: number, m: number, n: bigint, o: bigint, p: number, q: number) => [number, number, number, number];
 export const signRegister: (a: number, b: number, c: bigint, d: bigint, e: number, f: number, g: bigint, h: bigint) => [number, number, number, number];
 export const sign_call: (a: number, b: number, c: bigint, d: number, e: number, f: number, g: number, h: bigint, i: bigint, j: number, k: number, l: bigint, m: bigint, n: number, o: number) => [number, number, number, number];
 export const sign_transfer: (a: number, b: number, c: bigint, d: number, e: number, f: number, g: number, h: bigint, i: number, j: number, k: bigint, l: bigint) => [number, number, number, number];
+export const signingsession_checkTarget: (a: number, b: number, c: number) => [number, number];
+export const signingsession_isHeld: (a: number, b: number, c: number, d: bigint) => number;
+export const signingsession_new: (a: number, b: number) => [number, number, number];
+export const signingsession_nextNonce: (a: number, b: number, c: number) => [number, bigint];
+export const signingsession_outcome: (a: number, b: number, c: number, d: bigint, e: number) => void;
+export const signingsession_rememberAddress: (a: number, b: number, c: number) => void;
+export const signingsession_signed: (a: number, b: number, c: number, d: bigint) => void;
+export const signingsession_slot: (a: number, b: number, c: number, d: bigint, e: number, f: bigint, g: number) => [bigint, number, number];
 export const storageBody: (a: number, b: number) => [number, number];
 export const storageValue: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const submit_body: (a: number, b: number) => [number, number, number, number];
 export const testnetChainId: () => bigint;
+export const testnetChainName: () => [number, number];
+export const testnetRpcUrl: () => [number, number];
 export const tokenDecimalsSlot: () => bigint;
 export const tokenSymbolSlot: () => bigint;
 export const transaction_body: (a: number, b: number) => [number, number];
 export const unpackSymbol: (a: bigint) => [number, number];
 export const valid_address: (a: number, b: number) => number;
+export const validityBlocks: () => bigint;
 export const vmCallFee: (a: number, b: number, c: bigint) => [number, number, number, number];
 export const vmDeployAddress: () => [number, number];
 export const __wbindgen_malloc: (a: number, b: number) => number;

package/pkg-node/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-node/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qcore-js",
   "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-node/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-node/qcore_js.js

@@ -1,5 +1,109 @@
 /* @ts-self-types="./qcore_js.d.ts" */
 
+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;
+exports.SigningSession = SigningSession;
+
 /**
  * @param {string} address
  * @returns {string}
@@ -108,21 +212,42 @@ function block_by_height_body(height) {
 }
 exports.block_by_height_body = block_by_height_body;
 
+/**
+ * @param {string} chain_name
+ * @param {bigint} head
+ * @param {bigint} wall_secs
+ * @param {bigint | null | undefined} floor
+ * @param {bigint} floor_age_secs
+ * @returns {bigint}
+ */
+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]);
+}
+exports.boundedValidUntil = boundedValidUntil;
+
 /**
  * @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}
  */
-function buildSignedOrderCall(chain_id, contract, selector_hex, scheme_off, ptr_off, field_offs_csv, fields_csv, region_off, owner_seed_bytes, owner_index, nonce) {
+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 {
@@ -136,7 +261,7 @@ function buildSignedOrderCall(chain_id, contract, selector_hex, scheme_off, ptr_
         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]) {
@@ -158,14 +283,16 @@ exports.buildSignedOrderCall = buildSignedOrderCall;
  * @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}
  */
-function buildTypedOrderCall(chain_id, contract, selector_hex, scheme_off, ptr_off, region_off, fields_json, owner_seed_bytes, owner_index, nonce) {
+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 {
@@ -177,7 +304,7 @@ function buildTypedOrderCall(chain_id, contract, selector_hex, scheme_off, ptr_o
         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]) {
@@ -205,6 +332,19 @@ function chainIdFromName(name) {
 }
 exports.chainIdFromName = chainIdFromName;
 
+/**
+ * @param {string} response
+ */
+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]);
+    }
+}
+exports.checkGatewayJson = checkGatewayJson;
+
 /**
  * @param {bigint} valid_until
  * @param {bigint} head
@@ -253,6 +393,31 @@ function eventsBody(height) {
 }
 exports.eventsBody = eventsBody;
 
+/**
+ * @param {string} chain_name
+ * @returns {bigint}
+ */
+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);
+}
+exports.genesisSecs = genesisSecs;
+
+/**
+ * @param {string} chain_name
+ * @param {bigint} wall_secs
+ * @returns {bigint}
+ */
+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);
+}
+exports.headCeiling = headCeiling;
+
 /**
  * @returns {bigint}
  */
@@ -348,18 +513,35 @@ exports.mapSlotKey = mapSlotKey;
 
 /**
  * @param {Uint8Array} seed_bytes
- * @returns {any}
+ * @returns {Uint8Array}
  */
 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;
+}
+exports.mnemonicFromSeed = mnemonicFromSeed;
+
+/**
+ * @param {Uint8Array} seed_bytes
+ * @returns {any}
+ */
+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]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.mnemonicFromSeed = mnemonicFromSeed;
+exports.mnemonicFromSeedText = mnemonicFromSeedText;
 
 /**
  * @param {string} label
@@ -522,6 +704,23 @@ function seedFromMnemonic(phrase) {
 }
 exports.seedFromMnemonic = seedFromMnemonic;
 
+/**
+ * @param {Uint8Array} phrase
+ * @returns {Uint8Array}
+ */
+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;
+}
+exports.seedFromMnemonicBytes = seedFromMnemonicBytes;
+
 /**
  * @param {Uint8Array} seed_bytes
  * @param {bigint} index
@@ -816,6 +1015,40 @@ function testnetChainId() {
 }
 exports.testnetChainId = testnetChainId;
 
+/**
+ * @returns {string}
+ */
+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);
+    }
+}
+exports.testnetChainName = testnetChainName;
+
+/**
+ * @returns {string}
+ */
+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);
+    }
+}
+exports.testnetRpcUrl = testnetRpcUrl;
+
 /**
  * @returns {bigint}
  */
@@ -884,6 +1117,15 @@ function valid_address(address) {
 }
 exports.valid_address = valid_address;
 
+/**
+ * @returns {bigint}
+ */
+function validityBlocks() {
+    const ret = wasm.validityBlocks();
+    return BigInt.asUintN(64, ret);
+}
+exports.validityBlocks = validityBlocks;
+
 /**
  * @param {string} transfer_fee
  * @param {bigint} meter_limit
@@ -966,6 +1208,10 @@ function __wbg_get_imports() {
     };
 }
 
+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);