@neuraiproject/neurai-assets 1.7.2 → 1.8.1

package/README.md

@@ -37,6 +37,28 @@ Complete asset management library for Neurai blockchain. Supports creation, reis
 > (full name, owner `!` included: 31 mainnet / 121 testnet-regtest, validated
 > against a regtest node); peer `neurai-rpc ^0.6.0`.
 
+## 1.8.1: Issue quantities given as decimal strings
+
+`createRootAsset`, `createSubAsset`, `createDepinAsset` and
+`createRestrictedAsset` failed with `Invalid parameter, missing asset data for
+key: asset_quantity` when `quantity` was a decimal string such as `"1000"`.
+The node reads `asset_quantity` and `change_quantity` only from JSON numbers,
+and the value reached `createrawtransaction` quoted. It is now converted on the
+copy sent to the node: a JavaScript number when that number writes back the
+same decimal, otherwise an exact decimal token written as a bare JSON number by
+`@neuraiproject/neurai-rpc` (same shape as its `rpcNumber()`). The outputs in
+the build result keep the value as it was given. Numeric quantities are
+unchanged.
+
+## 1.8.0: Reset testnet marker policy
+
+Testnet builders require the node's `getblockchaininfo.asset_marker` value
+(or an explicit override) and reject a missing marker instead of silently
+using `rvn` after the activation of `xna`. This release requires
+`@neuraiproject/neurai-rpc` `^0.7.0` as a peer and
+`@neuraiproject/neurai-create-transaction` `^0.9.2`. Development tests use
+`@neuraiproject/neurai-sign-transaction` `^3.0.3`.
+
 ## Features
 
 - ✅ **Non-custodial**: Library builds unsigned transactions, your wallet signs them
@@ -79,6 +101,14 @@ either silently inflates the minted supply (`× 10⁸ → 100,000,000` tokens
 where the user asked for 1) or trips the daemon's
 `ParseFixedPoint` cap with `Invalid amount (3): …`.
 
+A quantity can be a number or a plain decimal string (`"1000.25"`). A string
+keeps every digit; it is sent to the node as a JSON number, which is the only
+form `createrawtransaction` accepts for `asset_quantity`. A decimal that no
+JavaScript number carries exactly is sent as an exact token, which requires
+the RPC function to serialize with `@neuraiproject/neurai-rpc` (its
+`getRPC()` does); any other serializer makes the node reject the call instead
+of changing the amount.
+
 This was regressed in `1.2.2`/`1.3.x` (a hardcoded `× 10⁸` was added to
 `BaseAssetTransactionBuilder.toSatoshis`) and fixed in the version after
 `1.3.1`. If you write a custom builder, follow the same convention: pass
@@ -786,7 +816,7 @@ The library automatically validates that the owner token is returned in each ope
 
 Asset payloads open with a 3-byte marker that NIP-040 migrates from the
 Ravencoin-inherited `rvn` to `xna` at an activation height per network
-(testnet: 303000, already crossed; regtest: 1; mainnet: not scheduled yet).
+(reset testnet: 10; regtest: 1; mainnet: not scheduled yet).
 
 - Transactions built **through the node** (`createrawtransaction`) need
   nothing: the node stamps the marker itself.
@@ -797,10 +827,12 @@ Ravencoin-inherited `rvn` to `xna` at an activation height per network
      `'xna'` — offline builds or tests);
   2. otherwise the node's `getblockchaininfo.asset_marker` (node commit
      `347362b` or later);
-  3. `'rvn'` when the node predates that field — which matches what such a
-     node enforces.
+  3. On mainnet, `'rvn'` when the node predates that field. Testnet requires
+     the field or an explicit `assetMarker` override.
 
-No height tables and no network inference: the node (or you) decides.
+The node reports the marker for the next block. On the reset testnet it reports
+`rvn` with tip 8 and `xna` with tip 9. The builder does not infer a marker
+from the network name.
 
 ### Failure policy (`assetMarkerPolicy`, 1.5.0+)
 
@@ -811,16 +843,16 @@ not answer at all is a different situation, and `assetMarkerPolicy` decides it:
 const assets = new NeuraiAssets(rpc, {
   network: 'xna-test',
   addresses: [...],
-  assetMarkerPolicy: 'strict'   // default: 'legacy-fallback'
+  assetMarkerPolicy: 'strict'   // default on testnet
 });
 ```
 
 | Policy | `getblockchaininfo` fails | Field absent/null | Unknown value |
 | --- | --- | --- | --- |
-| `legacy-fallback` (default in 1.x) | resolves `'rvn'` | resolves `'rvn'` | throws |
-| `strict` | **throws** | resolves `'rvn'` | throws |
+| `legacy-fallback` (mainnet default) | resolves `'rvn'` | mainnet: `'rvn'`; testnet: throws | throws |
+| `strict` (testnet default) | **throws** | mainnet: `'rvn'`; testnet: throws | throws |
 
-Use `strict` in a connected wallet on a post-NIP-040 chain: guessing `'rvn'`
+The reset testnet defaults to `strict`. Guessing `'rvn'`
 there builds a transaction the node rejects with
 `bad-txns-legacy-asset-marker-after-nip040`, so "the node did not answer" must
 not silently become "the node said rvn". The rejection propagates out of the
@@ -893,8 +925,8 @@ Address types (every family is valid with the network label of its chain):
 
 The old `nq1p...` / `tnq1p...` encoding of generic AuthScript v1 is rejected, like
 in the node (same scriptPubKey: regenerate it as `nc1p...` / `tnc1p...`). The node
-only protects a witness family where it is active: today v1 on testnet and regtest,
-v2 / v3 only on regtest.
+only protects a witness family where it is active. All three families activate
+on the reset testnet from block 10 and on regtest from block 1.
 
 The library accepts these network names. A label only selects the chain: the
 address type always comes from the address itself.

package/dist/NeuraiAssets.global.js

@@ -1931,8 +1931,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		 * Every transfer / new / owner / reissue payload opens with a 3-byte marker
 		 * followed by the type byte. The marker is consensus: blocks below the NIP-040
 		 * activation height of a network only accept `rvn` on new asset outputs and
-		 * blocks at or above it only accept `xna` (mainnet: not scheduled; testnet:
-		 * 303000; regtest: 1). This library does NOT know chain state and never
+		 * blocks at or above it only accept `xna` (mainnet: not scheduled; reset testnet:
+		 * 10; regtest: 1). This library does NOT know chain state and never
 		 * infers the marker from a network or an address: the caller passes the
 		 * value reported by the node for the next block
 		 * (`getblockchaininfo.asset_marker`, node commit 347362b) — or, when building
@@ -8299,6 +8299,140 @@ var NeuraiAssetsBundle = (function (exports) {
 		return validators$1;
 	}
 
+	/**
+	 * Asset amounts as `createrawtransaction` must receive them.
+	 *
+	 * The node reads `asset_quantity` (issue, issue_restricted, issue_qualifier,
+	 * reissue, reissue_restricted) and `change_quantity` (qualifier and tag
+	 * operations) only from JSON numbers: a quoted value fails `isNum()` and the
+	 * call is rejected with "missing asset data for key: asset_quantity". The
+	 * builders accept these amounts as decimal strings, which keep every digit the
+	 * caller wrote, so they are turned into JSON numbers here, on the copy of the
+	 * outputs sent to the node. The outputs returned to the caller keep the value
+	 * as it was given.
+	 */
+
+	var rpcAmount;
+	var hasRequiredRpcAmount;
+
+	function requireRpcAmount () {
+		if (hasRequiredRpcAmount) return rpcAmount;
+		hasRequiredRpcAmount = 1;
+		const {
+		  expandScientificNotation,
+		  formatRawAsDecimal,
+		  normalizeDecimalText,
+		  scaleDecimalText
+		} = requireAssetAmount();
+
+		/** Fields the node parses with `isNum()` inside an asset operation object. */
+		const NUMERIC_OPERATION_FIELDS = ['asset_quantity', 'change_quantity'];
+
+		/** The largest magnitude whose 8-decimal values a double still names exactly. */
+		const MAX_EXACT_FRACTIONAL = Number.MAX_SAFE_INTEGER / 1e8;
+
+		/**
+		 * An exact decimal serialized as a bare JSON number token.
+		 *
+		 * Same shape as `rpcNumber()` from @neuraiproject/neurai-rpc: its
+		 * `stringifyRpcJson` (lossless-json) writes any object flagged
+		 * `isLosslessNumber` through `toString()`. It is defined here instead of
+		 * imported because the bundles inline every dependency and neurai-rpc carries
+		 * its whole RPC reference. With another serializer it stays an object, which
+		 * the node rejects: it can never become a different amount.
+		 */
+		class RpcDecimal {
+		  /**
+		   * @param {string} text - Plain decimal text
+		   */
+		  constructor(text) {
+		    this.isLosslessNumber = true;
+		    this.value = text;
+		  }
+
+		  toString() {
+		    return this.value;
+		  }
+		}
+
+		/**
+		 * Convert an amount into a JSON-number value for `createrawtransaction`.
+		 *
+		 * Numbers pass through, as before. A decimal string becomes a JavaScript
+		 * number when that number writes back the same decimal (every JSON serializer
+		 * handles it), and an {@link RpcDecimal} otherwise, so no digit is rounded.
+		 *
+		 * @param {string|number} value - Display amount
+		 * @param {string} [label] - Field name, for error messages
+		 * @returns {number|RpcDecimal} JSON-number value
+		 * @throws {InvalidAmountError} If a string is not an exact 8-decimal amount
+		 */
+		function toRpcAmount(value, label = 'amount') {
+		  if (typeof value !== 'string') {
+		    return value;
+		  }
+		  const text = formatRawAsDecimal(scaleDecimalText(normalizeDecimalText(value, label), 8, label));
+		  const number = Number(text);
+		  const exact = Number.isFinite(number) &&
+		    expandScientificNotation(String(number)) === text &&
+		    (Number.isInteger(number) ? Number.isSafeInteger(number) : Math.abs(number) <= MAX_EXACT_FRACTIONAL);
+		  return exact ? number : new RpcDecimal(text);
+		}
+
+		function isPlainObject(value) {
+		  return value !== null && typeof value === 'object' && !Array.isArray(value);
+		}
+
+		/**
+		 * Copy of `createrawtransaction` outputs with the numeric asset fields
+		 * converted by {@link toRpcAmount}. XNA amounts and every other field are left
+		 * as they are: the node reads those with `AmountFromValue`, which also accepts
+		 * strings.
+		 *
+		 * @param {Array<object>|object} outputs - Outputs as built (array of single-key objects, or one object)
+		 * @returns {Array<object>|object} Outputs to send, same shape
+		 */
+		function prepareOutputsForRpc(outputs) {
+		  const convertPayload = (payload) => {
+		    if (!isPlainObject(payload)) {
+		      return payload;
+		    }
+		    const converted = {};
+		    for (const [operation, params] of Object.entries(payload)) {
+		      if (!isPlainObject(params)) {
+		        converted[operation] = params;
+		        continue;
+		      }
+		      const copy = { ...params };
+		      for (const field of NUMERIC_OPERATION_FIELDS) {
+		        if (copy[field] !== undefined && copy[field] !== null) {
+		          copy[field] = toRpcAmount(copy[field], field);
+		        }
+		      }
+		      converted[operation] = copy;
+		    }
+		    return converted;
+		  };
+
+		  const convertOutput = (output) => {
+		    const converted = {};
+		    for (const [address, payload] of Object.entries(output)) {
+		      converted[address] = convertPayload(payload);
+		    }
+		    return converted;
+		  };
+
+		  return Array.isArray(outputs) ? outputs.map(convertOutput) : convertOutput(outputs);
+		}
+
+		rpcAmount = {
+		  RpcDecimal,
+		  toRpcAmount,
+		  prepareOutputsForRpc
+		};
+		return rpcAmount;
+	}
+
 	/**
 	 * Base Asset Transaction Builder
 	 * Abstract base class for all transaction builders
@@ -8335,6 +8469,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		  toProtocolInteger,
 		  sumProtocolIntegers
 		} = requireAssetAmount();
+		const { prepareOutputsForRpc } = requireRpcAmount();
 
 		/** Outputs below this are dust and are dropped instead of created. */
 		const DUST_SATS = 1n;
@@ -8655,10 +8790,11 @@ var NeuraiAssetsBundle = (function (exports) {
 		        vout: input.vout !== undefined ? input.vout : input.outputIndex
 		      }));
 
-		      // Call createrawtransaction
+		      // Call createrawtransaction. The node only accepts the asset quantities
+		      // as JSON numbers; the caller's outputs keep the values as given.
 		      const rawTx = await this.rpc('createrawtransaction', [
 		        formattedInputs,
-		        outputs
+		        prepareOutputsForRpc(outputs)
 		      ]);
 
 		      return rawTx;
@@ -8799,11 +8935,15 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * 10^8 — e.g. reissuing 1 token of a units=0 asset minted 100,000,000).
 		   * The right answer is to send the value untouched.
 		   *
+		   * A decimal string is also kept as it is: `buildRawTransaction` turns it
+		   * into the JSON number the node requires (see utils/rpcAmount.js), and the
+		   * outputs returned to the caller keep the string.
+		   *
 		   * The `units` parameter is kept for API compatibility but is unused.
 		   *
-		   * @param {number} amount - User-facing asset amount
+		   * @param {number|string} amount - User-facing asset amount
 		   * @param {number} units - Asset decimal places (unused; kept for API)
-		   * @returns {number} The user-facing amount, ready for the JSON output
+		   * @returns {number|string} The user-facing amount, ready for the JSON output
 		   */
 		  toSatoshis(amount, units) {
 		    return amount;
@@ -8859,14 +8999,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		   *   1. `params.assetMarker` (explicit caller override — offline builds,
 		   *      tests, or a node this library should not ask);
 		   *   2. `getblockchaininfo.asset_marker` from the connected node;
-		   *   3. `'rvn'` when the node predates the field (a node without it enforces
-		   *      the legacy marker, so that is the right answer, not a guess).
+		   *   3. On mainnet, `'rvn'` when the field is absent. Testnet requires
+		   *      the field or an explicit override.
 		   *
 		   * An RPC *failure* is a different case, and `params.assetMarkerPolicy`
 		   * decides it:
-		   *   - `'legacy-fallback'` (default in 1.x) resolves `'rvn'`, preserving the
-		   *     1.4.x behaviour;
-		   *   - `'strict'` propagates the failure. On a post-NIP-040 chain a build
+		   *   - `'legacy-fallback'` (mainnet default) resolves `'rvn'`;
+		   *   - `'strict'` (testnet default) propagates the failure. On a post-NIP-040 chain a build
 		   *     that guessed `'rvn'` produces a transaction the node rejects with
 		   *     `bad-txns-legacy-asset-marker-after-nip040`, so an online wallet
 		   *     should not treat "the node did not answer" as "the node said rvn".
@@ -8894,7 +9033,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		  assetMarkerPolicy() {
 		    const policy = this.params.assetMarkerPolicy;
 		    if (policy === undefined || policy === null) {
-		      return 'legacy-fallback';
+		      return getNetworkConfig(this.network).baseNetwork === 'xna-test' ? 'strict' : 'legacy-fallback';
 		    }
 		    if (policy !== 'strict' && policy !== 'legacy-fallback') {
 		      throw new Error(
@@ -8932,7 +9071,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    }
 		    const marker = info ? info.asset_marker : undefined;
 		    if (marker === undefined || marker === null) {
-		      // A valid answer from a node that predates the field: legacy is correct.
+		      if (getNetworkConfig(this.network).baseNetwork === 'xna-test') {
+		        throw new Error('Testnet node did not report asset_marker; pass params.assetMarker for an offline build');
+		      }
 		      return 'rvn';
 		    }
 		    if (marker !== 'rvn' && marker !== 'xna') {
@@ -12632,14 +12773,11 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * @param {string} config.toAddress - Default receiving address
 		   * @param {('rvn'|'xna')} [config.assetMarker] - NIP-040 marker for locally
 		   *   built raw transactions. Omit to use the node's
-		   *   getblockchaininfo.asset_marker (falls back to 'rvn' on nodes that do
-		   *   not report it). Per-operation params.assetMarker overrides this.
+		   *   getblockchaininfo.asset_marker. A missing field fails on testnet and
+		   *   falls back to 'rvn' on mainnet. Per-operation params.assetMarker overrides this.
 		   * @param {('strict'|'legacy-fallback')} [config.assetMarkerPolicy] - What to
-		   *   do when getblockchaininfo FAILS. 'legacy-fallback' (default in 1.x)
-		   *   resolves 'rvn'; 'strict' propagates the error instead, because on a
-		   *   post-NIP-040 chain a guessed 'rvn' builds a transaction the node
-		   *   rejects. A node that simply predates the field still resolves 'rvn'
-		   *   under both policies — that is an answer, not a failure.
+		   *   do when getblockchaininfo fails. Testnet defaults to 'strict'; mainnet
+		   *   defaults to 'legacy-fallback'. An absent field always fails on testnet.
 		   */
 		  constructor(rpc, config = {}) {
 		    if (!rpc || typeof rpc !== 'function') {