@neuraiproject/neurai-assets 1.8.0 → 1.8.2

package/README.md

@@ -37,6 +37,31 @@ 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.2: Transfer amounts given as decimal strings
+
+`transferAsset` failed with `Invalid parameter, missing or invalid quantity`
+on nodes before Neurai-DePIN `9834b03` (mainnet and testnet at the time of
+writing) when a recipient `amount` was a decimal string such as `"5"`, or when
+the asset change back to the sender was one that no JavaScript number carries
+exactly (the builder writes those as text). Those nodes read the amounts of
+`transfer` and `transferwithmessage` only from JSON numbers, like
+`asset_quantity`. They are now converted the same way as in 1.8.1, on the copy
+sent to the node; `message` and `expire_time` are left untouched. Numeric
+amounts are unchanged.
+
+## 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
@@ -85,8 +110,17 @@ via `CheckAmountWithUnits`. Because the chain already does the ×10⁸ scaling
 itself, **the library must NOT pre-multiply** the value. Sending the raw
 display number is the only correct behavior; any extra factor on the wire
 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): …`.
+where the user asked for 1) or falls outside the range the daemon's amount
+parser accepts, with `Invalid amount (3): …`.
+
+A quantity or transfer amount 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, the only form nodes before Neurai-DePIN `9834b03` accept for asset
+amounts in `createrawtransaction` (newer nodes accept both). 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

package/dist/NeuraiAssets.global.js

@@ -8299,6 +8299,161 @@ var NeuraiAssetsBundle = (function (exports) {
 		return validators$1;
 	}
 
+	/**
+	 * Asset amounts as `createrawtransaction` must receive them.
+	 *
+	 * Nodes before Neurai-DePIN 9834b03 read every asset amount of
+	 * `createrawtransaction` only from JSON numbers: `asset_quantity` (issue,
+	 * issue_restricted, issue_qualifier, reissue, reissue_restricted),
+	 * `change_quantity` (qualifier and tag operations) and the amounts of
+	 * `transfer` and `transferwithmessage`. A quoted value fails `isNum()` and the
+	 * call is rejected ("missing asset data for key: asset_quantity", "missing or
+	 * invalid quantity"). The builders accept these amounts as decimal strings,
+	 * which keep every digit the caller wrote, and produce some themselves (an
+	 * asset change that no JavaScript number carries exactly), so they are turned
+	 * into JSON numbers here, on the copy of the outputs sent to the node. Newer
+	 * nodes accept both forms. 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'];
+
+		/**
+		 * Operations whose keys are asset names mapped to amounts. `transferwithmessage`
+		 * also carries `message` (a string) and `expire_time` (an integer), which are
+		 * not amounts and are left alone.
+		 */
+		const TRANSFER_OPERATIONS = ['transfer', 'transferwithmessage'];
+		const TRANSFER_NON_AMOUNT_KEYS = ['message', 'expire_time'];
+
+		/** 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 asset amounts converted by
+		 * {@link toRpcAmount}: `asset_quantity` and `change_quantity`, and the amounts
+		 * of `transfer` / `transferwithmessage`. XNA amounts and every other field are
+		 * left as they are: the node reads XNA amounts 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 };
+		      if (TRANSFER_OPERATIONS.includes(operation)) {
+		        for (const [key, value] of Object.entries(copy)) {
+		          if (!TRANSFER_NON_AMOUNT_KEYS.includes(key) && value !== undefined && value !== null) {
+		            copy[key] = toRpcAmount(value, `${operation} amount of ${key}`);
+		          }
+		        }
+		      } else {
+		        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 +8490,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 +8811,12 @@ var NeuraiAssetsBundle = (function (exports) {
 		        vout: input.vout !== undefined ? input.vout : input.outputIndex
 		      }));
 
-		      // Call createrawtransaction
+		      // Call createrawtransaction. Nodes before Neurai-DePIN 9834b03 only
+		      // accept asset amounts as JSON numbers; the caller's outputs keep the
+		      // values as given.
 		      const rawTx = await this.rpc('createrawtransaction', [
 		        formattedInputs,
-		        outputs
+		        prepareOutputsForRpc(outputs)
 		      ]);
 
 		      return rawTx;
@@ -8790,8 +8948,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		   *     (e.g. "1" for one token, "1.5" for one and a half tokens).
 		   *   - The lib must NOT pre-multiply by 10^8 or 10^units; the daemon
 		   *     does the 10^8 scaling itself, and any extra factor here lands
-		   *     duplicated and inflates the minted supply (or trips the
-		   *     ParseFixedPoint `exponent >= 18` cap → "Invalid amount (3)").
+		   *     duplicated and inflates the minted supply (or falls outside the
+		   *     range the node's amount parser accepts → "Invalid amount (3)").
 		   *
 		   * History: pre-1.2.2 multiplied by 10^units (correct only for units=0
 		   * assets, inflated everything else by 10^units). v1.2.2 changed to
@@ -8799,11 +8957,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;