@quantovainc/qcore 0.2.0 → 0.2.2

package/pkg-node/qcore_js.js

@@ -205,6 +205,18 @@ function chainIdFromName(name) {
 }
 exports.chainIdFromName = chainIdFromName;
 
+/**
+ * @param {bigint} valid_until
+ * @param {bigint} head
+ */
+function checkValidUntil(valid_until, head) {
+    const ret = wasm.checkValidUntil(valid_until, head);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+exports.checkValidUntil = checkValidUntil;
+
 /**
  * @param {string} deployer
  * @param {bigint} nonce
@@ -250,6 +262,26 @@ function localChainId() {
 }
 exports.localChainId = localChainId;
 
+/**
+ * @param {string} candidate
+ * @param {string[]} known
+ * @returns {string | undefined}
+ */
+function lookalikeOf(candidate, known) {
+    const ptr0 = passStringToWasm0(candidate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayJsValueToWasm0(known, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.lookalikeOf(ptr0, len0, ptr1, len1);
+    let v3;
+    if (ret[0] !== 0) {
+        v3 = getStringFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v3;
+}
+exports.lookalikeOf = lookalikeOf;
+
 /**
  * @returns {bigint}
  */
@@ -440,6 +472,21 @@ function parseEvents(response) {
 }
 exports.parseEvents = parseEvents;
 
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+function sameAddress(a, b) {
+    const ptr0 = passStringToWasm0(a, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(b, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.sameAddress(ptr0, len0, ptr1, len1);
+    return ret !== 0;
+}
+exports.sameAddress = sameAddress;
+
 /**
  * @param {bigint} slot
  * @returns {string}
@@ -485,11 +532,12 @@ exports.seedFromMnemonic = seedFromMnemonic;
  * @param {string} fee
  * @param {bigint} chain_id
  * @param {bigint} valid_until
+ * @param {string | null} [transfer_fee]
  * @returns {string}
  */
-function signAssetCall(seed_hex, index, target, args_hex, asset_issuer, amount, nonce, meter_limit, fee, chain_id, valid_until) {
-    let deferred8_0;
-    let deferred8_1;
+function signAssetCall(seed_hex, index, target, args_hex, asset_issuer, amount, nonce, meter_limit, fee, chain_id, valid_until, transfer_fee) {
+    let deferred9_0;
+    let deferred9_1;
     try {
         const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
@@ -503,18 +551,20 @@ function signAssetCall(seed_hex, index, target, args_hex, asset_issuer, amount,
         const len4 = WASM_VECTOR_LEN;
         const ptr5 = passStringToWasm0(fee, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len5 = WASM_VECTOR_LEN;
-        const ret = wasm.signAssetCall(ptr0, len0, index, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, nonce, meter_limit, ptr5, len5, chain_id, valid_until);
-        var ptr7 = ret[0];
-        var len7 = ret[1];
+        var ptr6 = isLikeNone(transfer_fee) ? 0 : passStringToWasm0(transfer_fee, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len6 = WASM_VECTOR_LEN;
+        const ret = wasm.signAssetCall(ptr0, len0, index, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, nonce, meter_limit, ptr5, len5, chain_id, valid_until, ptr6, len6);
+        var ptr8 = ret[0];
+        var len8 = ret[1];
         if (ret[3]) {
-            ptr7 = 0; len7 = 0;
+            ptr8 = 0; len8 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred8_0 = ptr7;
-        deferred8_1 = len7;
-        return getStringFromWasm0(ptr7, len7);
+        deferred9_0 = ptr8;
+        deferred9_1 = len8;
+        return getStringFromWasm0(ptr8, len8);
     } finally {
-        wasm.__wbindgen_free(deferred8_0, deferred8_1, 1);
+        wasm.__wbindgen_free(deferred9_0, deferred9_1, 1);
     }
 }
 exports.signAssetCall = signAssetCall;
@@ -530,11 +580,12 @@ exports.signAssetCall = signAssetCall;
  * @param {string} value
  * @param {bigint} chain_id
  * @param {bigint} valid_until
+ * @param {string | null} [transfer_fee]
  * @returns {string}
  */
-function signPayableCall(seed_hex, index, target, args_hex, nonce, meter_limit, fee, value, chain_id, valid_until) {
-    let deferred7_0;
-    let deferred7_1;
+function signPayableCall(seed_hex, index, target, args_hex, nonce, meter_limit, fee, value, chain_id, valid_until, transfer_fee) {
+    let deferred8_0;
+    let deferred8_1;
     try {
         const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
@@ -546,18 +597,20 @@ function signPayableCall(seed_hex, index, target, args_hex, nonce, meter_limit,
         const len3 = WASM_VECTOR_LEN;
         const ptr4 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len4 = WASM_VECTOR_LEN;
-        const ret = wasm.signPayableCall(ptr0, len0, index, ptr1, len1, ptr2, len2, nonce, meter_limit, ptr3, len3, ptr4, len4, chain_id, valid_until);
-        var ptr6 = ret[0];
-        var len6 = ret[1];
+        var ptr5 = isLikeNone(transfer_fee) ? 0 : passStringToWasm0(transfer_fee, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len5 = WASM_VECTOR_LEN;
+        const ret = wasm.signPayableCall(ptr0, len0, index, ptr1, len1, ptr2, len2, nonce, meter_limit, ptr3, len3, ptr4, len4, chain_id, valid_until, ptr5, len5);
+        var ptr7 = ret[0];
+        var len7 = ret[1];
         if (ret[3]) {
-            ptr6 = 0; len6 = 0;
+            ptr7 = 0; len7 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred7_0 = ptr6;
-        deferred7_1 = len6;
-        return getStringFromWasm0(ptr6, len6);
+        deferred8_0 = ptr7;
+        deferred8_1 = len7;
+        return getStringFromWasm0(ptr7, len7);
     } finally {
-        wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
+        wasm.__wbindgen_free(deferred8_0, deferred8_1, 1);
     }
 }
 exports.signPayableCall = signPayableCall;
@@ -605,11 +658,12 @@ exports.signRegister = signRegister;
  * @param {string} fee
  * @param {bigint} chain_id
  * @param {bigint} valid_until
+ * @param {string | null} [transfer_fee]
  * @returns {string}
  */
-function sign_call(seed_hex, index, target, args_hex, nonce, meter_limit, fee, chain_id, valid_until) {
-    let deferred6_0;
-    let deferred6_1;
+function sign_call(seed_hex, index, target, args_hex, nonce, meter_limit, fee, chain_id, valid_until, transfer_fee) {
+    let deferred7_0;
+    let deferred7_1;
     try {
         const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
@@ -619,18 +673,20 @@ function sign_call(seed_hex, index, target, args_hex, nonce, meter_limit, fee, c
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passStringToWasm0(fee, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.sign_call(ptr0, len0, index, ptr1, len1, ptr2, len2, nonce, meter_limit, ptr3, len3, chain_id, valid_until);
-        var ptr5 = ret[0];
-        var len5 = ret[1];
+        var ptr4 = isLikeNone(transfer_fee) ? 0 : passStringToWasm0(transfer_fee, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len4 = WASM_VECTOR_LEN;
+        const ret = wasm.sign_call(ptr0, len0, index, ptr1, len1, ptr2, len2, nonce, meter_limit, ptr3, len3, chain_id, valid_until, ptr4, len4);
+        var ptr6 = ret[0];
+        var len6 = ret[1];
         if (ret[3]) {
-            ptr5 = 0; len5 = 0;
+            ptr6 = 0; len6 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred6_0 = ptr5;
-        deferred6_1 = len5;
-        return getStringFromWasm0(ptr5, len5);
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
     } finally {
-        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+        wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
     }
 }
 exports.sign_call = sign_call;
@@ -826,6 +882,33 @@ function valid_address(address) {
 }
 exports.valid_address = valid_address;
 
+/**
+ * @param {string} transfer_fee
+ * @param {bigint} meter_limit
+ * @returns {string}
+ */
+function vmCallFee(transfer_fee, meter_limit) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(transfer_fee, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.vmCallFee(ptr0, len0, meter_limit);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.vmCallFee = vmCallFee;
+
 /**
  * @returns {string}
  */
@@ -849,6 +932,17 @@ function __wbg_get_imports() {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
+        __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
@@ -870,6 +964,20 @@ function __wbg_get_imports() {
     };
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
@@ -882,6 +990,20 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/shared.js

@@ -63,7 +63,82 @@ const VALIDITY_BLOCKS = 300n;
 const MAX_PLAUSIBLE_HEAD = 1n << 40n;
 const HEAD_BLOCKS_PER_SEC = 4n;
 const HEAD_SLACK_SECS = 60n;
-const TRANSFER_METER = 1210n;
+const U64_MAX = 0xffffffffffffffffn;
+const U128_MAX = (1n << 128n) - 1n;
+
+function wholeNumber(value, label, max) {
+  let n;
+  if (typeof value === 'bigint') {
+    n = value;
+  } else if (typeof value === 'number') {
+    if (!Number.isSafeInteger(value)) {
+      throw new Error(`the ${label} must be a whole number in the safe integer range, a number outside it silently rounds, pass a decimal string or a BigInt`);
+    }
+    n = BigInt(value);
+  } else if (typeof value === 'string' && /^[0-9]+$/.test(value)) {
+    n = BigInt(value);
+  } else {
+    throw new Error(`the ${label} must be a string of decimal digits, a BigInt, or a safe integer number`);
+  }
+  if (n < 0n || n > max) {
+    throw new Error(`the ${label} must be a whole number from 0 to ${max}`);
+  }
+  return n;
+}
+
+function coreArg(kind, label, value) {
+  if (kind === 'text') {
+    if (typeof value !== 'string') throw new Error(`the ${label} must be a string`);
+    return value;
+  }
+  if (kind === 'u64') return wholeNumber(value, label, U64_MAX);
+  if (kind === 'u64s') return wholeNumber(value, label, U64_MAX).toString();
+  if (kind === 'u128s') return wholeNumber(value, label, U128_MAX).toString();
+  throw new Error(`unknown argument kind ${kind}`);
+}
+
+const CORE_ARGS = {
+  address: [['text', 'seed'], ['u64', 'account index']],
+  mnemonicFromSeed: [['text', 'seed']],
+  seedFromMnemonic: [['text', 'recovery phrase']],
+  orderSigner: [['text', 'seed'], ['u64', 'account index']],
+  sign_transfer: [['text', 'seed'], ['u64', 'account index'], ['text', 'recipient'], ['u64s', 'amount'], ['u64', 'nonce'], ['u128s', 'fee'], ['u64', 'chain id'], ['u64', 'validity deadline']],
+  signRegister: [['text', 'seed'], ['u64', 'account index'], ['u64', 'nonce'], ['u128s', 'fee'], ['u64', 'chain id'], ['u64', 'validity deadline']],
+  sign_call: [['text', 'seed'], ['u64', 'account index'], ['text', 'target'], ['text', 'call arguments'], ['u64', 'nonce'], ['u64', 'meter limit'], ['u128s', 'fee'], ['u64', 'chain id'], ['u64', 'validity deadline'], ['u128s', 'transfer fee']],
+  signPayableCall: [['text', 'seed'], ['u64', 'account index'], ['text', 'target'], ['text', 'call arguments'], ['u64', 'nonce'], ['u64', 'meter limit'], ['u128s', 'fee'], ['u64s', 'value'], ['u64', 'chain id'], ['u64', 'validity deadline'], ['u128s', 'transfer fee']],
+  signAssetCall: [['text', 'seed'], ['u64', 'account index'], ['text', 'target'], ['text', 'call arguments'], ['text', 'asset issuer'], ['u64s', 'amount'], ['u64', 'nonce'], ['u64', 'meter limit'], ['u128s', 'fee'], ['u64', 'chain id'], ['u64', 'validity deadline'], ['u128s', 'transfer fee']],
+  buildSignedOrderCall: [['u64', 'chain id'], ['text', 'contract'], ['text', 'selector'], ['u64', 'scheme offset'], ['u64', 'pointer offset'], ['text', 'field offsets'], ['text', 'fields'], ['u64', 'region offset'], ['text', 'owner seed'], ['u64', 'owner index'], ['u64', 'order nonce']],
+  buildTypedOrderCall: [['u64', 'chain id'], ['text', 'contract'], ['text', 'selector'], ['u64', 'scheme offset'], ['u64', 'pointer offset'], ['u64', 'region offset'], ['text', 'fields'], ['text', 'owner seed'], ['u64', 'owner index'], ['u64', 'order nonce']],
+  contractAddress: [['text', 'deployer'], ['u64', 'nonce']],
+  scalarSlotKey: [['u64', 'slot']],
+  mapSlotKey: [['u64', 'map domain tag'], ['text', 'key address']],
+  mapAddrWordKey: [['u64', 'map domain tag'], ['text', 'key'], ['u64', 'word']],
+  unpackSymbol: [['u64', 'symbol word']],
+  eventsBody: [['u64', 'height']],
+  block_by_height_body: [['u64', 'height']],
+  vmCallFee: [['u128s', 'transfer fee'], ['u64', 'meter limit']],
+  checkValidUntil: [['u64', 'validity deadline'], ['u64', 'head height']],
+};
+
+function wrapCore(raw) {
+  const core = Object.assign({}, raw);
+  for (const [name, kinds] of Object.entries(CORE_ARGS)) {
+    const fn = raw[name];
+    if (typeof fn !== 'function') continue;
+    core[name] = (...args) => fn(...kinds.map(([kind, label], i) => coreArg(kind, label, args[i])));
+  }
+  const fee = core.vmCallFee;
+  if (typeof fee === 'function') core.vmCallFee = (transferFee, meterLimit) => BigInt(fee(transferFee, meterLimit));
+  return Object.freeze(core);
+}
+
+function isMainnetChain(name) {
+  return name.startsWith('Q-main-net-');
+}
+
+function isPublicChain(name) {
+  return name.startsWith('Q-test-net-') || isMainnetChain(name);
+}
 
 function meterLimitOf(meterLimit) {
   if (typeof meterLimit === 'number' && !Number.isSafeInteger(meterLimit)) {
@@ -81,13 +156,6 @@ function meterLimitOf(meterLimit) {
   return meter;
 }
 
-function vmCallFee(transferFee, meterLimit) {
-  const meter = meterLimitOf(meterLimit);
-  let units = (meter + TRANSFER_METER - 1n) / TRANSFER_METER;
-  if (units < 1n) units = 1n;
-  return BigInt(transferFee) * units;
-}
-
 function validUntil(info) {
   const head = info && info.head_height;
   if (head == null) throw new Error('the gateway did not report a head height to bound the transaction to');
@@ -201,7 +269,7 @@ class Network {
   static testnet() {
     return new Network({
       name: 'testnet',
-      chainId: 'Q-test-net-3',
+      chainId: 'Q-test-net-1',
       rpcUrl: 'https://rpc-testnet.quantova.org',
       explorerUrl: 'https://qvmscan.io',
       isMainnet: false,
@@ -271,13 +339,17 @@ function makeClient(core) {
       const name = info && info.chain_id;
       if (!name) throw new Error('the gateway did not report a chain id to bind the signature to');
       if (typeof name !== 'string') throw new Error('the gateway reported a chain id that is not a string, refusing to bind a signature to it');
-      const id = BigInt(core.chainIdFromName(name));
       const configured =
         this.expectedChainId || (this.network && this.network.chainId) || null;
-      if (configured && name !== configured) {
-        throw new Error(`the gateway reports chain ${name} but this client is configured for ${configured}; refusing to sign a transaction that would be valid on a network you did not choose`);
+      const mainnet = isMainnetChain(name);
+      if (configured) {
+        if (name !== configured) {
+          throw new Error(`the gateway reports chain ${name} but this client is configured for ${configured}; refusing to sign a transaction that would be valid on a network you did not choose`);
+        }
+      } else if (isPublicChain(name) && !(mainnet && this.acknowledgeMainnet)) {
+        throw new Error(`the gateway reports the public chain ${name} but this client was opened for an unnamed network; configure the testnet or mainnet network before signing for it`);
       }
-      if (!this.acknowledgeMainnet && this._isMainnetId(id)) {
+      if (mainnet && !this.acknowledgeMainnet) {
         throw new Error(`the gateway reports the mainnet chain ${name}; refusing to sign a mainnet transaction without acknowledgeMainnet`);
       }
       if (this._pinnedChainName === null) {
@@ -285,11 +357,7 @@ function makeClient(core) {
       } else if (this._pinnedChainName !== name) {
         throw new Error(`the gateway reported chain ${this._pinnedChainName} earlier and now reports ${name}; refusing to sign, the endpoint is not naming one network`);
       }
-      return id;
-    }
-
-    _isMainnetId(id) {
-      return id === BigInt(core.mainnetChainId());
+      return BigInt(core.chainIdFromName(name));
     }
 
     async _call(method, body) {
@@ -330,40 +398,47 @@ function makeClient(core) {
     }
     _checkedNonce(reported, expected, key) {
       const n = accountNonce(reported);
+      if (expected != null) {
+        const e = wholeNumber(expected, 'expected nonce', U64_MAX);
+        if (e !== n) {
+          throw new Error(`the gateway reported nonce ${n} but you expected ${e}; the chain admits only the nonce the account has reached, refusing to sign`);
+        }
+      }
       if (!this._nextNonces) this._nextNonces = new Map();
-      if (!this._signedNonces) this._signedNonces = new Map();
-      const local = key != null ? this._nextNonces.get(key) : undefined;
-      const e = expected != null ? BigInt(expected) : local;
-      let slot;
-      if (e == null) {
-        slot = n;
-      } else {
-        if (n > e) throw new Error(`the gateway reported nonce ${n} above the expected ${e}; refusing so a signature cannot be banked for a nonce the account has not reached`);
-        slot = expected != null ? e : n;
+      if (key != null) {
+        const local = this._nextNonces.get(key);
+        if (local == null || local < n) this._nextNonces.set(key, n);
       }
-      return slot;
+      return n;
     }
 
-    // Refuse a second, different transaction at a nonce this session already
-    // signed at. A gateway can broadcast a transaction and still report it
-    // rejected, or walk the nonce it reports back to a slot already used.
-    // Either way two valid signatures for one slot let it choose which the
-    // chain runs. An identical retry is harmless and still allowed.
-    _guardSigned(key, slot, txHex) {
+    _guardSigned(key, slot, txHex, until, explicit) {
       if (key == null) return;
       if (!this._signedNonces) this._signedNonces = new Map();
       let held = this._signedNonces.get(key);
       if (!held) { held = new Map(); this._signedNonces.set(key, held); }
+      const head = until - VALIDITY_BLOCKS;
+      for (const [slotKey, entry] of held) {
+        if (head > entry.until) held.delete(slotKey);
+      }
       const seen = held.get(String(slot));
-      if (seen != null && seen !== txHex) {
-        throw new Error(`a different transaction was already signed for nonce ${slot} in this session; one nonce carries one signature`);
+      if (!explicit && seen != null && seen.txHex !== txHex) {
+        throw new Error(`a different transaction was already signed for nonce ${slot} in this session and was neither rejected nor expired; one nonce carries one signature, pass the nonce explicitly to replace one that never landed`);
       }
-      held.set(String(slot), txHex);
+      held.set(String(slot), { txHex, until });
     }
 
     _remember(key, used, outcome) {
       if (!this._nextNonces) this._nextNonces = new Map();
-      if (outcome && outcome.verdict === 'accepted') this._nextNonces.set(key, BigInt(used) + 1n);
+      const verdict = outcome && outcome.verdict;
+      if (verdict === 'accepted') {
+        const next = BigInt(used) + 1n;
+        const local = this._nextNonces.get(key);
+        if (local == null || local < next) this._nextNonces.set(key, next);
+      } else if (verdict === 'rejected') {
+        const held = this._signedNonces && this._signedNonces.get(key);
+        if (held) held.delete(String(used));
+      }
     }
 
     _validity(info) {
@@ -376,9 +451,9 @@ function makeClient(core) {
         const elapsed = now > at ? now - at : 0n;
         const allowed = (elapsed + HEAD_SLACK_SECS) * HEAD_BLOCKS_PER_SEC;
         if (head > height + allowed) throw new Error(`the gateway head leapt from ${height} to ${head} faster than blocks are made, refusing to sign`);
-      } else {
-        this._headFloor = { height: head, at: now };
       }
+      core.checkValidUntil(until, head);
+      if (!this._headFloor || head > this._headFloor.height) this._headFloor = { height: head, at: now };
       return until;
     }
     transaction(txId) { return this._call('get_transaction', core.transaction_body(txId)); }
@@ -403,14 +478,15 @@ function makeClient(core) {
       if (fee > ceiling) {
         throw new Error(`the gateway fee ${fee} is above the maximum you allowed ${maxFeeQuon}, refusing to sign`);
       }
+      const until = this._validity(info);
       const from = core.address(seedHex, accountIndex(index));
       const acct = await this.account(from);
       if (!acct || acct.nonce == null) throw new Error('the gateway did not report a nonce');
       const nonce = this._checkedNonce(acct.nonce, expectedNonce, from);
       const signed = JSON.parse(
-        core.sign_transfer(seedHex, accountIndex(index), to, String(amount), nonce, String(fee), chainId, this._validity(info))
+        core.sign_transfer(seedHex, accountIndex(index), to, String(amount), nonce, String(fee), chainId, until)
       );
-      this._guardSigned(from, nonce, signed.tx_hex);
+      this._guardSigned(from, nonce, signed.tx_hex, until, expectedNonce != null);
       const outcome = await this.submit(signed.tx_hex);
       this._remember(from, nonce, outcome);
       return { signed, outcome };
@@ -427,12 +503,13 @@ function makeClient(core) {
       if (fee > ceiling) {
         throw new Error(`the gateway fee ${fee} is above the maximum you allowed ${maxFeeQuon}, refusing to sign`);
       }
+      const until = this._validity(info);
       const from = core.address(seedHex, accountIndex(index));
       const acct = await this.account(from);
       if (!acct || acct.nonce == null) throw new Error('the gateway did not report a nonce');
       const nonce = this._checkedNonce(acct.nonce, expectedNonce, from);
-      const signed = JSON.parse(core.signRegister(seedHex, accountIndex(index), nonce, String(fee), chainId, this._validity(info)));
-      this._guardSigned(from, nonce, signed.tx_hex);
+      const signed = JSON.parse(core.signRegister(seedHex, accountIndex(index), nonce, String(fee), chainId, until));
+      this._guardSigned(from, nonce, signed.tx_hex, until, expectedNonce != null);
       const outcome = await this.submit(signed.tx_hex);
       this._remember(from, nonce, outcome);
       return { signed, outcome };
@@ -446,18 +523,20 @@ function makeClient(core) {
       const chainId = this._signingChainId(info);
       const reported = info && info.fee && info.fee.transfer_quon;
       if (reported == null) throw new Error('the gateway did not report a transfer fee');
-      const fee = vmCallFee(gatewayFee(reported), meterLimit);
+      const transferFee = gatewayFee(reported);
+      const fee = BigInt(core.vmCallFee(String(transferFee), meterLimitOf(meterLimit)));
       if (fee > ceiling) {
         throw new Error(`the fee ${fee} is above the maximum you allowed ${maxFeeQuon}, refusing to sign`);
       }
+      const until = this._validity(info);
       const from = core.address(seedHex, accountIndex(index));
       const acct = await this.account(from);
       if (!acct || acct.nonce == null) throw new Error('the gateway did not report a nonce');
       const nonce = this._checkedNonce(acct.nonce, expectedNonce, from);
       const signed = JSON.parse(
-        core.sign_call(seedHex, accountIndex(index), target, argsHex, nonce, meterLimitOf(meterLimit), String(fee), chainId, this._validity(info))
+        core.sign_call(seedHex, accountIndex(index), target, argsHex, nonce, meterLimitOf(meterLimit), String(fee), chainId, until, String(transferFee))
       );
-      this._guardSigned(from, nonce, signed.tx_hex);
+      this._guardSigned(from, nonce, signed.tx_hex, until, expectedNonce != null);
       const outcome = await this.submit(signed.tx_hex);
       this._remember(from, nonce, outcome);
       return { signed, outcome };
@@ -473,18 +552,20 @@ function makeClient(core) {
       const chainId = this._signingChainId(info);
       const reported = info && info.fee && info.fee.transfer_quon;
       if (reported == null) throw new Error('the gateway did not report a transfer fee');
-      const fee = vmCallFee(gatewayFee(reported), meterLimit);
+      const transferFee = gatewayFee(reported);
+      const fee = BigInt(core.vmCallFee(String(transferFee), meterLimitOf(meterLimit)));
       if (fee > ceiling) {
         throw new Error(`the fee ${fee} is above the maximum you allowed ${maxFeeQuon}, refusing to sign`);
       }
+      const until = this._validity(info);
       const from = core.address(seedHex, accountIndex(index));
       const acct = await this.account(from);
       if (!acct || acct.nonce == null) throw new Error('the gateway did not report a nonce');
       const nonce = this._checkedNonce(acct.nonce, expectedNonce, from);
       const signed = JSON.parse(
-        core.signAssetCall(seedHex, accountIndex(index), target, argsHex, assetIssuer, String(amount), nonce, meterLimitOf(meterLimit), String(fee), chainId, this._validity(info))
+        core.signAssetCall(seedHex, accountIndex(index), target, argsHex, assetIssuer, String(amount), nonce, meterLimitOf(meterLimit), String(fee), chainId, until, String(transferFee))
       );
-      this._guardSigned(from, nonce, signed.tx_hex);
+      this._guardSigned(from, nonce, signed.tx_hex, until, expectedNonce != null);
       const outcome = await this.submit(signed.tx_hex);
       this._remember(from, nonce, outcome);
       return { signed, outcome };
@@ -499,18 +580,20 @@ function makeClient(core) {
       const chainId = this._signingChainId(info);
       const reported = info && info.fee && info.fee.transfer_quon;
       if (reported == null) throw new Error('the gateway did not report a transfer fee');
-      const fee = vmCallFee(gatewayFee(reported), meterLimit);
+      const transferFee = gatewayFee(reported);
+      const fee = BigInt(core.vmCallFee(String(transferFee), meterLimitOf(meterLimit)));
       if (fee > ceiling) {
         throw new Error(`the fee ${fee} is above the maximum you allowed ${maxFeeQuon}, refusing to sign`);
       }
+      const until = this._validity(info);
       const from = core.address(seedHex, accountIndex(index));
       const acct = await this.account(from);
       if (!acct || acct.nonce == null) throw new Error('the gateway did not report a nonce');
       const nonce = this._checkedNonce(acct.nonce, expectedNonce, from);
       const signed = JSON.parse(
-        core.signPayableCall(seedHex, accountIndex(index), target, argsHex, nonce, meterLimitOf(meterLimit), String(fee), String(value), chainId, this._validity(info))
+        core.signPayableCall(seedHex, accountIndex(index), target, argsHex, nonce, meterLimitOf(meterLimit), String(fee), String(value), chainId, until, String(transferFee))
       );
-      this._guardSigned(from, nonce, signed.tx_hex);
+      this._guardSigned(from, nonce, signed.tx_hex, until, expectedNonce != null);
       const outcome = await this.submit(signed.tx_hex);
       this._remember(from, nonce, outcome);
       return { signed, outcome };
@@ -537,10 +620,12 @@ function makeClient(core) {
       const chainId = this._signingChainId(info);
       const reported = info && info.fee && info.fee.transfer_quon;
       if (reported == null) throw new Error('the gateway did not report a transfer fee');
-      const fee = vmCallFee(gatewayFee(reported), meterLimit);
+      const transferFee = gatewayFee(reported);
+      const fee = BigInt(core.vmCallFee(String(transferFee), meterLimitOf(meterLimit)));
       if (fee > ceiling) {
         throw new Error(`the fee ${fee} is above the maximum you allowed ${maxFeeQuon}, refusing to sign`);
       }
+      const until = this._validity(info);
       const signer = core.orderSigner(ownerSeedHex, accountIndex(ownerIndex));
       const orderKey = contract + '/' + signer;
       const reportedOrder = await this.contractNonce(contract, signer);
@@ -572,9 +657,9 @@ function makeClient(core) {
       if (!acct || acct.nonce == null) throw new Error('the gateway did not report a nonce');
       const accountNonceUsed = this._checkedNonce(acct.nonce, expectedNonce, from);
       const signed = JSON.parse(
-        core.sign_call(callerSeedHex, accountIndex(callerIndex), contract, order.call_args, accountNonceUsed, meterLimitOf(meterLimit), String(fee), chainId, this._validity(info))
+        core.sign_call(callerSeedHex, accountIndex(callerIndex), contract, order.call_args, accountNonceUsed, meterLimitOf(meterLimit), String(fee), chainId, until, String(transferFee))
       );
-      this._guardSigned(from, nonce, signed.tx_hex);
+      this._guardSigned(from, accountNonceUsed, signed.tx_hex, until, expectedNonce != null);
       const outcome = await this.submit(signed.tx_hex);
       this._remember(from, accountNonceUsed, outcome);
       this._remember(orderKey, nonce, outcome);
@@ -583,4 +668,4 @@ function makeClient(core) {
   };
 }
 
-module.exports = { makeClient, feeCeiling, checkAmount, generateSeed, readBounded, requireSafeTransport, validUntil, vmCallFee, VALIDITY_BLOCKS, Network };
+module.exports = { makeClient, wrapCore, feeCeiling, checkAmount, generateSeed, readBounded, requireSafeTransport, validUntil, VALIDITY_BLOCKS, Network };