@neuraiproject/neurai-assets 1.8.0 → 1.8.1

package/README.md

@@ -37,6 +37,19 @@ 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
@@ -88,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

package/dist/NeuraiAssets.global.js

@@ -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;