@neuraiproject/neurai-assets 1.3.2 → 1.4.0

package/dist/NeuraiAssets.global.js

@@ -7,6 +7,55 @@ var NeuraiAssetsBundle = (function (exports) {
 
 	var src = {exports: {}};
 
+	/**
+	 * Extract a human-readable message from an RPC rejection.
+	 *
+	 * @neuraiproject/neurai-rpc >= 0.5 never rejects with a plain Error, so
+	 * `error.message` is undefined for every node failure. It uses three shapes:
+	 *
+	 *   1. {error: {code, message}, description}      JSON-RPC error (also on HTTP 200)
+	 *   2. {statusText, status, description, error}   HTTP response other than 200
+	 *   3. {originalError, type: 'ServerUnreachable', error, description}
+	 *
+	 * In shape 3 `error` is a string, in shapes 1 and 2 it is an object (or
+	 * null). Plain Errors (thrown by this library or by mocks) keep working
+	 * through the `error.message` candidate.
+	 */
+
+	var rpcErrorMessage_1;
+	var hasRequiredRpcErrorMessage;
+
+	function requireRpcErrorMessage () {
+		if (hasRequiredRpcErrorMessage) return rpcErrorMessage_1;
+		hasRequiredRpcErrorMessage = 1;
+		function rpcErrorMessage(error) {
+		  if (!error) {
+		    return '';
+		  }
+		  if (typeof error === 'string') {
+		    return error;
+		  }
+
+		  const candidates = [
+		    error.error && error.error.message,
+		    typeof error.error === 'string' ? error.error : null,
+		    error.description,
+		    error.message,
+		    error.statusText
+		  ];
+
+		  for (const candidate of candidates) {
+		    if (typeof candidate === 'string' && candidate.length > 0) {
+		      return candidate;
+		    }
+		  }
+		  return '';
+		}
+
+		rpcErrorMessage_1 = { rpcErrorMessage };
+		return rpcErrorMessage_1;
+	}
+
 	/**
 	 * Validation Error Classes
 	 * Errors thrown during parameter validation
@@ -332,6 +381,7 @@ var NeuraiAssetsBundle = (function (exports) {
 	function requireAssetQueries () {
 		if (hasRequiredAssetQueries) return AssetQueries_1;
 		hasRequiredAssetQueries = 1;
+		const { rpcErrorMessage } = requireRpcErrorMessage();
 		const { AssetNotFoundError, InvalidAddressError } = requireErrors();
 
 		class AssetQueries {
@@ -373,14 +423,14 @@ var NeuraiAssetsBundle = (function (exports) {
 		      }
 
 		      // RPC error - likely asset doesn't exist
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        throw new AssetNotFoundError(
 		          `Asset ${assetName} not found on blockchain`,
 		          assetName
 		        );
 		      }
 
-		      throw new Error(`Failed to get asset data: ${error.message}`);
+		      throw new Error(`Failed to get asset data: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -397,7 +447,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const assets = await this.rpc('listassets', [filter, verbose, count, start]);
 		      return assets || [];
 		    } catch (error) {
-		      throw new Error(`Failed to list assets: ${error.message}`);
+		      throw new Error(`Failed to list assets: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -415,7 +465,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const myAssets = await this.rpc('listmyassets', [assetName, verbose, count, start, confs]);
 		      return myAssets || {};
 		    } catch (error) {
-		      throw new Error(`Failed to list my assets: ${error.message}`);
+		      throw new Error(`Failed to list my assets: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -436,13 +486,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const result = await this.rpc('listaddressesbyasset', [assetName, onlyCount, count, start]);
 		      return result || (onlyCount ? 0 : []);
 		    } catch (error) {
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        throw new AssetNotFoundError(
 		          `Asset ${assetName} not found on blockchain`,
 		          assetName
 		        );
 		      }
-		      throw new Error(`Failed to list addresses by asset: ${error.message}`);
+		      throw new Error(`Failed to list addresses by asset: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -463,7 +513,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const result = await this.rpc('listassetbalancesbyaddress', [address, onlyTotal, count, start]);
 		      return result || (onlyTotal ? 0 : []);
 		    } catch (error) {
-		      throw new Error(`Failed to list asset balances by address: ${error.message}`);
+		      throw new Error(`Failed to list asset balances by address: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -487,10 +537,10 @@ var NeuraiAssetsBundle = (function (exports) {
 		      return result === true || result === 1;
 		    } catch (error) {
 		      // If tag doesn't exist or address doesn't have it, return false
-		      if (error.message && (error.message.includes('not found') || error.message.includes('does not have'))) {
+		      if (rpcErrorMessage(error).includes('not found') || rpcErrorMessage(error).includes('does not have')) {
 		        return false;
 		      }
-		      throw new Error(`Failed to check address tag: ${error.message}`);
+		      throw new Error(`Failed to check address tag: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -509,10 +559,10 @@ var NeuraiAssetsBundle = (function (exports) {
 		      return tags || [];
 		    } catch (error) {
 		      // If no tags found, return empty array
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        return [];
 		      }
-		      throw new Error(`Failed to list tags for address: ${error.message}`);
+		      throw new Error(`Failed to list tags for address: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -530,13 +580,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const addresses = await this.rpc('listaddressesfortag', [qualifierName]);
 		      return addresses || [];
 		    } catch (error) {
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        throw new AssetNotFoundError(
 		          `Qualifier ${qualifierName} not found on blockchain`,
 		          qualifierName
 		        );
 		      }
-		      throw new Error(`Failed to list addresses for tag: ${error.message}`);
+		      throw new Error(`Failed to list addresses for tag: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -560,10 +610,10 @@ var NeuraiAssetsBundle = (function (exports) {
 		      return result === true || result === 1;
 		    } catch (error) {
 		      // If address doesn't meet requirements, return false
-		      if (error.message && (error.message.includes('not found') || error.message.includes('does not meet'))) {
+		      if (rpcErrorMessage(error).includes('not found') || rpcErrorMessage(error).includes('does not meet')) {
 		        return false;
 		      }
-		      throw new Error(`Failed to check address restriction: ${error.message}`);
+		      throw new Error(`Failed to check address restriction: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -590,7 +640,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      }
 		      return false;
 		    } catch (error) {
-		      throw new Error(`Failed to check if address is frozen: ${error.message}`);
+		      throw new Error(`Failed to check if address is frozen: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -608,13 +658,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const result = await this.rpc('checkglobalrestriction', [restrictedAssetName]);
 		      return result === true || result === 1;
 		    } catch (error) {
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        throw new AssetNotFoundError(
 		          `Restricted asset ${restrictedAssetName} not found on blockchain`,
 		          restrictedAssetName
 		        );
 		      }
-		      throw new Error(`Failed to check global restriction: ${error.message}`);
+		      throw new Error(`Failed to check global restriction: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -632,13 +682,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const result = await this.rpc('getverifierstring', [restrictedAssetName]);
 		      return result || '';
 		    } catch (error) {
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        throw new AssetNotFoundError(
 		          `Restricted asset ${restrictedAssetName} not found on blockchain`,
 		          restrictedAssetName
 		        );
 		      }
-		      throw new Error(`Failed to get verifier string: ${error.message}`);
+		      throw new Error(`Failed to get verifier string: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -680,7 +730,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const result = await this.rpc('getsnapshotrequest', [assetName, blockHeight]);
 		      return result;
 		    } catch (error) {
-		      throw new Error(`Failed to get snapshot request: ${error.message}`);
+		      throw new Error(`Failed to get snapshot request: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -703,7 +753,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const result = await this.rpc('cancelsnapshotrequest', [assetName, blockHeight]);
 		      return result === true || result === 1;
 		    } catch (error) {
-		      throw new Error(`Failed to cancel snapshot request: ${error.message}`);
+		      throw new Error(`Failed to cancel snapshot request: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -721,13 +771,13 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const result = await this.rpc('listdepinholders', [assetName]);
 		      return result || [];
 		    } catch (error) {
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        throw new AssetNotFoundError(
 		          `DEPIN asset ${assetName} not found on blockchain`,
 		          assetName
 		        );
 		      }
-		      throw new Error(`Failed to list DEPIN holders: ${error.message}`);
+		      throw new Error(`Failed to list DEPIN holders: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -750,7 +800,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const result = await this.rpc('checkdepinvalidity', [assetName, address]);
 		      return result || { has_asset: false };
 		    } catch (error) {
-		      throw new Error(`Failed to check DEPIN validity: ${error.message}`);
+		      throw new Error(`Failed to check DEPIN validity: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -764,7 +814,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      const assets = await this.listAssets('*', false, 1, 0);
 		      return Array.isArray(assets) ? assets.length : 0;
 		    } catch (error) {
-		      throw new Error(`Failed to get asset count: ${error.message}`);
+		      throw new Error(`Failed to get asset count: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -1050,7 +1100,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		    addressPrefix: 'N',
 		    authScriptAddressPrefix: 'nq1',
 		    pqAddressPrefix: 'nq1',
-		    assetNameMaxLength: 32,
+		    assetNameMaxLength: 31,
 		    defaultRPCPort: 19001,
 		    coin: 'XNA',
 		    baseNetwork: 'xna'
@@ -1061,7 +1111,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		    addressPrefix: 't',
 		    authScriptAddressPrefix: 'tnq1',
 		    pqAddressPrefix: 'tnq1',
-		    assetNameMaxLength: 32,  // Same as mainnet
+		    assetNameMaxLength: 121, // DePIN networks (testnet/regtest) extend the cap
 		    defaultRPCPort: 19101,
 		    coin: 'TXNA',
 		    baseNetwork: 'xna-test'
@@ -1072,7 +1122,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		    addressPrefix: 'N',
 		    authScriptAddressPrefix: 'nq1',
 		    pqAddressPrefix: 'nq1',
-		    assetNameMaxLength: 32,
+		    assetNameMaxLength: 31,
 		    defaultRPCPort: 19001,
 		    coin: 'XNA',
 		    baseNetwork: 'xna'
@@ -1083,7 +1133,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		    addressPrefix: 't',
 		    authScriptAddressPrefix: 'tnq1',
 		    pqAddressPrefix: 'tnq1',
-		    assetNameMaxLength: 32,
+		    assetNameMaxLength: 121,
 		    defaultRPCPort: 19101,
 		    coin: 'TXNA',
 		    baseNetwork: 'xna-test'
@@ -1911,6 +1961,8 @@ var NeuraiAssetsBundle = (function (exports) {
 	function requireNetworkDetector () {
 		if (hasRequiredNetworkDetector) return networkDetector;
 		hasRequiredNetworkDetector = 1;
+		const { rpcErrorMessage } = requireRpcErrorMessage();
+
 		const {
 		  NETWORKS,
 		  areAddressNetworksCompatible,
@@ -1945,7 +1997,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      // Default to mainnet
 		      return 'xna';
 		    } catch (error) {
-		      throw new Error(`Failed to detect network from RPC: ${error.message}`);
+		      throw new Error(`Failed to detect network from RPC: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -2465,6 +2517,7 @@ var NeuraiAssetsBundle = (function (exports) {
 	function requireOwnerTokenManager () {
 		if (hasRequiredOwnerTokenManager) return OwnerTokenManager_1;
 		hasRequiredOwnerTokenManager = 1;
+		const { rpcErrorMessage } = requireRpcErrorMessage();
 		const { AssetNameParser } = requireUtils();
 		const {
 		  OwnerTokenNotFoundError,
@@ -2523,7 +2576,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      }
 
 		      throw new AssetError(
-		        `Failed to find owner token ${ownerTokenName}: ${error.message}`
+		        `Failed to find owner token ${ownerTokenName}: ${rpcErrorMessage(error)}`
 		      );
 		    }
 		  }
@@ -2661,7 +2714,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      return ownerTokenUTXOs;
 		    } catch (error) {
 		      throw new AssetError(
-		        `Failed to get owner tokens: ${error.message}`
+		        `Failed to get owner tokens: ${rpcErrorMessage(error)}`
 		      );
 		    }
 		  }
@@ -2853,6 +2906,7 @@ var NeuraiAssetsBundle = (function (exports) {
 	function requireUTXOSelector () {
 		if (hasRequiredUTXOSelector) return UTXOSelector_1;
 		hasRequiredUTXOSelector = 1;
+		const { rpcErrorMessage } = requireRpcErrorMessage();
 		const { InsufficientFundsError } = requireErrors();
 		const { estimateTransactionVbytes } = requireFeeSizing();
 
@@ -2891,7 +2945,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        return utxos.filter(utxo => !utxo.assetName || utxo.assetName === 'XNA');
 		      }
 		    } catch (error) {
-		      throw new Error(`Failed to get UTXOs: ${error.message}`);
+		      throw new Error(`Failed to get UTXOs: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -3493,7 +3547,10 @@ var NeuraiAssetsBundle = (function (exports) {
 		const { InvalidAssetNameError } = requireErrors();
 
 		const MIN_ASSET_LENGTH = 3;
-		const MAINNET_MAX_NAME_LENGTH = 32;
+		// Full-name caps, mirror of the node (assets_fromscript.cpp:31-47): the limit
+		// applies to the COMPLETE name, owner '!' and tags included, so a mainnet
+		// root is effectively capped at 30 (its owner token "ROOT!" must fit in 31).
+		const MAINNET_MAX_NAME_LENGTH = 31;
 		const TESTNET_MAX_NAME_LENGTH = 121;
 
 		const ROOT_NAME_CHARACTERS = /^[A-Z0-9._]{3,}$/;
@@ -4363,6 +4420,7 @@ var NeuraiAssetsBundle = (function (exports) {
 	function requireBaseAssetTransactionBuilder () {
 		if (hasRequiredBaseAssetTransactionBuilder) return BaseAssetTransactionBuilder_1;
 		hasRequiredBaseAssetTransactionBuilder = 1;
+		const { rpcErrorMessage } = requireRpcErrorMessage();
 		const { BurnManager, OwnerTokenManager, UTXOSelector, OutputOrderer } = requireManagers();
 		const { AssetNameValidator, AmountValidator } = requireValidators();
 
@@ -4423,6 +4481,9 @@ var NeuraiAssetsBundle = (function (exports) {
 		    // post-selection recompute). The fee rate is stable for the duration of
 		    // a single build, so cache the first lookup and reuse it.
 		    this._feeRatePromise = null;
+
+		    // NIP-040 marker for the localRawBuild metadata; resolved once per build.
+		    this._assetMarkerPromise = null;
 		  }
 
 		  /**
@@ -4515,7 +4576,7 @@ var NeuraiAssetsBundle = (function (exports) {
 
 		      return rawTx;
 		    } catch (error) {
-		      throw new Error(`Failed to create raw transaction: ${error.message}`);
+		      throw new Error(`Failed to create raw transaction: ${rpcErrorMessage(error)}`);
 		    }
 		  }
 
@@ -4677,19 +4738,73 @@ var NeuraiAssetsBundle = (function (exports) {
 		    return Math.round(amount * 100000000);
 		  }
 
+		  /**
+		   * NIP-040 marker for every asset output of the localRawBuild metadata.
+		   *
+		   * The chain decides which marker ("rvn" or "xna") new asset outputs must
+		   * carry, per network and height, and the node reports the one required for
+		   * the next block as `getblockchaininfo.asset_marker` (node commit 347362b).
+		   * Resolution order:
+		   *   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 or the call fails
+		   *      (matches what such a node enforces; documented in the README).
+		   * The RPC-built transaction path never needs this: the node stamps the
+		   * marker itself in `createrawtransaction`.
+		   *
+		   * @returns {Promise<'rvn'|'xna'>} Marker for locally built asset outputs
+		   */
+		  resolveAssetMarker() {
+		    if (!this._assetMarkerPromise) {
+		      this._assetMarkerPromise = this._fetchAssetMarker();
+		    }
+		    return this._assetMarkerPromise;
+		  }
+
+		  async _fetchAssetMarker() {
+		    const override = this.params.assetMarker;
+		    if (override !== undefined && override !== null) {
+		      if (override !== 'rvn' && override !== 'xna') {
+		        throw new Error(
+		          `Invalid assetMarker: ${override} (expected 'rvn' or 'xna', the value of getblockchaininfo.asset_marker)`
+		        );
+		      }
+		      return override;
+		    }
+
+		    let info = null;
+		    try {
+		      info = await this.rpc('getblockchaininfo', []);
+		    } catch (error) {
+		      return 'rvn';
+		    }
+		    const marker = info ? info.asset_marker : undefined;
+		    if (marker === undefined || marker === null) {
+		      return 'rvn';
+		    }
+		    if (marker !== 'rvn' && marker !== 'xna') {
+		      throw new Error(`Node reported an unknown asset_marker: ${marker}`);
+		    }
+		    return marker;
+		  }
+
 		  /**
 		   * Build a typed local raw build payload compatible with
 		   * @neuraiproject/neurai-create-transaction createFromOperation(...)
 		   *
+		   * Stamps the NIP-040 `assetMarker` (see resolveAssetMarker) so
+		   * createFromOperation >= 0.7.0 emits the marker the chain requires.
+		   *
 		   * @param {string} operationType - Operation type
 		   * @param {Array} inputs - Builder inputs
 		   * @param {object|null} burnInfo - Burn metadata
 		   * @param {string|null} changeAddress - XNA change address
 		   * @param {number|null} changeAmount - XNA change amount in XNA
 		   * @param {object} operationParams - Operation-specific params
-		   * @returns {{ operationType: string, params: object }} Local raw build
+		   * @returns {Promise<{ operationType: string, params: object }>} Local raw build
 		   */
-		  buildLocalRawBuild(
+		  async buildLocalRawBuild(
 		    operationType,
 		    inputs,
 		    burnInfo = null,
@@ -4699,6 +4814,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		  ) {
 		    const params = {
 		      inputs: this.toRawTxInputs(inputs),
+		      assetMarker: await this.resolveAssetMarker(),
 		      ...operationParams
 		    };
 
@@ -4835,7 +4951,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		      return assetData !== null && assetData !== undefined;
 		    } catch (error) {
 		      // If asset doesn't exist, RPC will throw error
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        return false;
 		      }
 		      // Re-throw other errors
@@ -4852,7 +4968,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		    try {
 		      return await this.rpc('getassetdata', [assetName]);
 		    } catch (error) {
-		      if (error.message && error.message.includes('not found')) {
+		      if (rpcErrorMessage(error).includes('not found')) {
 		        return null;
 		      }
 		      throw error;
@@ -5038,7 +5154,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        assetName,
 		        ownerTokenName: assetName + '!',
 		        operationType: 'ISSUE_ROOT',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          'ISSUE_ROOT',
 		          inputs,
 		          burnInfo,
@@ -5306,7 +5422,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        ownerTokenName: assetName + '!',
 		        parentOwnerTokenUsed: ownerTokenName,
 		        operationType: 'ISSUE_SUB',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          'ISSUE_SUB',
 		          inputs,
 		          burnInfo,
@@ -5476,7 +5592,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        assetName,
 		        ownerTokenName: `${assetName}!`,
 		        operationType: 'ISSUE_DEPIN',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          'ISSUE_DEPIN',
 		          inputs,
 		          burnInfo,
@@ -5744,7 +5860,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        previousSupply: currentSupply,
 		        reissuableLocked: reissuable === false,
 		        operationType: 'REISSUE',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          'REISSUE',
 		          inputs,
 		          burnInfo,
@@ -5769,6 +5885,274 @@ var NeuraiAssetsBundle = (function (exports) {
 		return ReissueBuilder_1;
 	}
 
+	/**
+	 * Transfer Builder
+	 * Builds transactions that transfer an existing asset to one or more recipients.
+	 *
+	 * Works for any asset type (regular, sub, restricted, DePIN). The only
+	 * type-specific rule lives in Neurai consensus for DePIN (`&`) assets, which are
+	 * soulbound: a DePIN transfer is only valid if the same transaction
+	 *   1. SPENDS the asset's owner token `&NAME!` as an input, and
+	 *   2. re-creates (transfers) that owner token in an output.
+	 * See Neurai-DePIN/src/consensus/tx_verify.cpp (bad-txns-depin-transfer-not-by-owner).
+	 * For non-DePIN assets no owner token is required for a plain transfer.
+	 *
+	 * Owner-token destination: the owner token is returned to the sender's change
+	 * address — the asset moves to the recipient but authority stays with the owner
+	 * (soulbound semantics). Transferring ownership itself is out of scope here.
+	 *
+	 * This builder mirrors ReissueBuilder (which also spends + returns an owner
+	 * token) but, since a transfer has no reissue entry, it adds the owner-token
+	 * return output explicitly via OwnerTokenManager.
+	 */
+
+	var TransferBuilder_1;
+	var hasRequiredTransferBuilder;
+
+	function requireTransferBuilder () {
+		if (hasRequiredTransferBuilder) return TransferBuilder_1;
+		hasRequiredTransferBuilder = 1;
+		const BaseAssetTransactionBuilder = requireBaseAssetTransactionBuilder();
+		const { OutputFormatter, AssetNameParser } = requireUtils();
+		const { OwnerTokenNotFoundError } = requireErrors();
+
+		class TransferBuilder extends BaseAssetTransactionBuilder {
+		  /**
+		   * Validate transfer parameters
+		   * @param {object} params - Transfer parameters
+		   * @throws {Error} If validation fails
+		   */
+		  validateParams(params) {
+		    if (!params.assetName) {
+		      throw new Error('assetName is required');
+		    }
+
+		    if (!Array.isArray(params.recipients) || params.recipients.length === 0) {
+		      throw new Error('recipients is required (non-empty array of { address, amount })');
+		    }
+
+		    params.recipients.forEach((recipient, index) => {
+		      if (!recipient || !recipient.address) {
+		        throw new Error(`recipients[${index}].address is required`);
+		      }
+		      if (recipient.amount === undefined || recipient.amount === null) {
+		        throw new Error(`recipients[${index}].amount is required`);
+		      }
+		      if (recipient.amount <= 0) {
+		        throw new Error(`recipients[${index}].amount must be greater than 0`);
+		      }
+		    });
+
+		    return true;
+		  }
+
+		  /**
+		   * Build transfer transaction
+		   * @returns {Promise<object>} Transaction result
+		   */
+		  async build() {
+		    // 1. Validate parameters
+		    this.validateParams(this.params);
+
+		    const { assetName, recipients } = this.params;
+
+		    // Total amount to send, in user-facing asset units (NOT raw 10^8 sats).
+		    // selectAssetUTXOs / the createrawtransaction transfer output both expect
+		    // display units and scale by 10^8 themselves — pre-multiplying would
+		    // double-scale (see UTXOSelector.selectAssetUTXOs / BaseBuilder.toSatoshis).
+		    const totalAssetUnits = recipients.reduce((sum, r) => sum + r.amount, 0);
+
+		    // 2. Addresses
+		    const addresses = await this._getAddresses();
+		    const changeAddress = await this.getChangeAddress();
+
+		    // 3. DePIN detection + owner token lookup (soulbound rule)
+		    const isDepin = AssetNameParser.isDepin(assetName);
+		    let ownerTokenName = null;
+		    let ownerTokenUTXO = null;
+		    if (isDepin) {
+		      ownerTokenName = AssetNameParser.getOwnerTokenName(assetName); // &NAME -> &NAME!
+		      try {
+		        ownerTokenUTXO = await this.ownerTokenManager.findOwnerTokenUTXO(
+		          ownerTokenName,
+		          addresses
+		        );
+		      } catch (error) {
+		        if (error instanceof OwnerTokenNotFoundError) {
+		          throw new OwnerTokenNotFoundError(
+		            `You must own the asset's owner token (${ownerTokenName}) to transfer ` +
+		            `this DePIN asset. DePIN assets are soulbound: the transfer must be ` +
+		            `authorized by the owner.`,
+		            ownerTokenName
+		          );
+		        }
+		        throw error;
+		      }
+		    }
+
+		    // 4. Output addresses used only for the fee (vsize) estimate. Include every
+		    //    potential output so the fee is never under-estimated.
+		    const outputAddresses = [
+		      changeAddress, // XNA change
+		      ...recipients.map(r => r.address), // one transfer per recipient
+		      changeAddress, // asset change (harmless over-count if absent)
+		      ...(isDepin ? [changeAddress] : []), // owner token return
+		    ];
+
+		    // 5. First (rough) fee estimate, then select asset + XNA UTXOs.
+		    const estimatedFee = await this.estimateFee(isDepin ? 3 : 2, outputAddresses);
+		    const utxoSelection = await this.selectUTXOs(estimatedFee, assetName, totalAssetUnits);
+		    const assetUTXOs = utxoSelection.assetUTXOs;
+		    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
+		    let totalXNAInput = utxoSelection.totalXNA;
+
+		    // Asset change computed in raw 10^8-sats to avoid float drift, then back to units.
+		    const assetInputRawSats = assetUTXOs.reduce((sum, u) => sum + u.satoshis, 0);
+		    const totalAssetRawSats = Math.round(totalAssetUnits * 100000000);
+		    const assetChangeRawSats = assetInputRawSats - totalAssetRawSats;
+		    const assetChangeUnits = assetChangeRawSats / 100000000;
+
+		    // 6. Recompute the fee with the real inputs (PQ-aware), including the owner
+		    //    token when DePIN, then top up XNA if the rough estimate fell short.
+		    const actualFeeInputs = [
+		      ...baseCurrencyUTXOs,
+		      ...assetUTXOs,
+		      ...(isDepin ? [ownerTokenUTXO] : []),
+		    ];
+		    const actualFee = await this.estimateFee(actualFeeInputs, outputAddresses);
+
+		    if (totalXNAInput < actualFee) {
+		      const additionalNeeded = actualFee - totalXNAInput + 0.001;
+		      const additionalSelection = await this.selectUTXOs(additionalNeeded, null, 0);
+		      baseCurrencyUTXOs.push(...additionalSelection.xnaUTXOs);
+		      totalXNAInput += additionalSelection.totalXNA;
+		    }
+
+		    // 7. XNA change (no burn for a transfer)
+		    const finalXNAInput = baseCurrencyUTXOs.reduce(
+		      (sum, utxo) => sum + utxo.satoshis / 100000000,
+		      0
+		    );
+		    const xnaChange = finalXNAInput - actualFee;
+
+		    // 8. Build inputs: asset UTXOs + [owner token] + XNA UTXOs
+		    const inputs = [];
+
+		    assetUTXOs.forEach(utxo => {
+		      inputs.push({
+		        txid: utxo.txid,
+		        vout: utxo.outputIndex,
+		        address: utxo.address,
+		        assetName: utxo.assetName,
+		        satoshis: utxo.satoshis,
+		      });
+		    });
+
+		    if (isDepin) {
+		      inputs.push({
+		        txid: ownerTokenUTXO.txid,
+		        vout: ownerTokenUTXO.outputIndex,
+		        address: ownerTokenUTXO.address,
+		        assetName: ownerTokenUTXO.assetName,
+		        satoshis: ownerTokenUTXO.satoshis,
+		      });
+		    }
+
+		    baseCurrencyUTXOs.forEach(utxo => {
+		      inputs.push({
+		        txid: utxo.txid,
+		        vout: utxo.outputIndex,
+		        address: utxo.address,
+		        satoshis: utxo.satoshis,
+		      });
+		    });
+
+		    // 9. Build outputs (unordered — outputOrderer enforces protocol order)
+		    const outputs = [];
+
+		    // XNA change
+		    if (xnaChange > 0.00000001) {
+		      outputs.push({ [changeAddress]: parseFloat(xnaChange.toFixed(8)) });
+		    }
+
+		    // One transfer per recipient (display units; the daemon scales by 10^8)
+		    recipients.forEach(r => {
+		      outputs.push({ [r.address]: OutputFormatter.formatTransferOutput(assetName, r.amount) });
+		    });
+
+		    // Asset change back to the sender
+		    if (assetChangeRawSats > 0) {
+		      outputs.push({
+		        [changeAddress]: OutputFormatter.formatTransferOutput(assetName, assetChangeUnits),
+		      });
+		    }
+
+		    // DePIN: return the owner token (required so the tx contains a transfer of
+		    // &NAME! — satisfies the consensus `transfersOwnerToken` check).
+		    if (isDepin) {
+		      outputs.push(
+		        this.ownerTokenManager.createOwnerTokenReturnOutput(ownerTokenName, changeAddress)
+		      );
+		    }
+
+		    // 10. Order outputs (protocol requirement)
+		    const orderedOutputs = this.outputOrderer.order(outputs);
+
+		    // 11. Create raw transaction
+		    const rawTx = await this.buildRawTransaction(inputs, orderedOutputs);
+
+		    // 12. Format and return result
+		    const allUTXOs = [
+		      ...assetUTXOs,
+		      ...(isDepin ? [ownerTokenUTXO] : []),
+		      ...baseCurrencyUTXOs,
+		    ];
+		    const xnaChangeOut = xnaChange > 0.00000001 ? parseFloat(xnaChange.toFixed(8)) : null;
+
+		    return this.formatResult(
+		      rawTx,
+		      allUTXOs,
+		      inputs,
+		      orderedOutputs,
+		      actualFee,
+		      0, // burnAmount — transfers don't burn
+		      {
+		        assetName,
+		        recipients: recipients.map(r => ({ address: r.address, amount: r.amount })),
+		        assetChange: assetChangeRawSats > 0 ? assetChangeUnits : 0,
+		        isDepin,
+		        ownerTokenUsed: isDepin ? ownerTokenName : null,
+		        operationType: 'TRANSFER',
+		        localRawBuild: await this.buildLocalRawBuild(
+		          'TRANSFER',
+		          inputs,
+		          null, // no burn
+		          changeAddress,
+		          xnaChangeOut,
+		          {
+		            assetName,
+		            transfers: recipients.map(r => ({
+		              address: r.address,
+		              assetName,
+		              amount: r.amount,
+		            })),
+		            assetChange: assetChangeRawSats > 0
+		              ? { address: changeAddress, assetName, amount: assetChangeUnits }
+		              : null,
+		            ownerReturn: isDepin
+		              ? { address: changeAddress, assetName: ownerTokenName, amount: 1 }
+		              : null,
+		          }
+		        ),
+		      }
+		    );
+		  }
+		}
+
+		TransferBuilder_1 = TransferBuilder;
+		return TransferBuilder_1;
+	}
+
 	/**
 	 * Issue Unique Builder
 	 * Builds transactions for creating UNIQUE assets (NFTs)
@@ -6023,7 +6407,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        nftCount,
 		        ownerTokenUsed: ownerTokenName,
 		        operationType: 'ISSUE_UNIQUE',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          'ISSUE_UNIQUE',
 		          inputs,
 		          burnInfo,
@@ -6284,7 +6668,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        parentQualifier: isSub ? parsed.parent : null,
 		        parentQualifierUsed: parentQualifierName,
 		        operationType: isSub ? 'ISSUE_SUB_QUALIFIER' : 'ISSUE_QUALIFIER',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          isSub ? 'ISSUE_SUB_QUALIFIER' : 'ISSUE_QUALIFIER',
 		          inputs,
 		          burnInfo,
@@ -6538,7 +6922,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        verifierString,
 		        requiredQualifiers,
 		        operationType: 'ISSUE_RESTRICTED',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          'ISSUE_RESTRICTED',
 		          inputs,
 		          burnInfo,
@@ -6824,7 +7208,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        requiredQualifiers,
 		        reissuableLocked: reissuable === false,
 		        operationType: 'REISSUE_RESTRICTED',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          'REISSUE_RESTRICTED',
 		          inputs,
 		          burnInfo,
@@ -7066,7 +7450,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        targetAddresses,
 		        addressCount,
 		        operationType: isUntag ? 'UNTAG_ADDRESSES' : 'TAG_ADDRESSES',
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          isUntag ? 'UNTAG_ADDRESSES' : 'TAG_ADDRESSES',
 		          inputs,
 		          burnInfo,
@@ -7328,7 +7712,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		        targetAddresses: targetAddresses.length > 0 ? targetAddresses : null,
 		        addressCount: targetAddresses.length,
 		        operationType,
-		        localRawBuild: this.buildLocalRawBuild(
+		        localRawBuild: await this.buildLocalRawBuild(
 		          operationType,
 		          inputs,
 		          null,
@@ -7405,6 +7789,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		const IssueSubBuilder = requireIssueSubBuilder();
 		const IssueDepinBuilder = requireIssueDepinBuilder();
 		const ReissueBuilder = requireReissueBuilder();
+		const TransferBuilder = requireTransferBuilder();
 
 		// Advanced Builders
 		const IssueUniqueBuilder = requireIssueUniqueBuilder();
@@ -7423,6 +7808,7 @@ var NeuraiAssetsBundle = (function (exports) {
 		  IssueSubBuilder,
 		  IssueDepinBuilder,
 		  ReissueBuilder,
+		  TransferBuilder,
 
 		  // Advanced Builders
 		  IssueUniqueBuilder,
@@ -7475,7 +7861,8 @@ var NeuraiAssetsBundle = (function (exports) {
 		  ReissueBuilder,
 		  ReissueRestrictedBuilder,
 		  TagAddressBuilder,
-		  FreezeAddressBuilder
+		  FreezeAddressBuilder,
+		  TransferBuilder
 		} = requireBuilders();
 
 		class NeuraiAssets {
@@ -7486,6 +7873,10 @@ var NeuraiAssetsBundle = (function (exports) {
 		   * @param {Array<string>} config.addresses - Wallet addresses
 		   * @param {string} config.changeAddress - Default change address
 		   * @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.
 		   */
 		  constructor(rpc, config = {}) {
 		    if (!rpc || typeof rpc !== 'function') {
@@ -7523,7 +7914,10 @@ var NeuraiAssetsBundle = (function (exports) {
 		      network: this.config.network,
 		      walletAddresses: this.config.addresses,
 		      changeAddress: params.changeAddress || this.config.changeAddress,
-		      toAddress: params.toAddress || this.config.toAddress
+		      toAddress: params.toAddress || this.config.toAddress,
+		      // NIP-040: marker for the localRawBuild metadata. Undefined lets the
+		      // builder ask the node (getblockchaininfo.asset_marker).
+		      assetMarker: params.assetMarker !== undefined ? params.assetMarker : this.config.assetMarker
 		    };
 		  }
 
@@ -7592,6 +7986,32 @@ var NeuraiAssetsBundle = (function (exports) {
 		    return await builder.build();
 		  }
 
+		  // ========================================
+		  // TRANSFER OPERATIONS
+		  // ========================================
+
+		  /**
+		   * Transfer an existing asset to one or more recipients.
+		   *
+		   * Works for any asset type. DePIN (`&`) assets are soulbound: this method
+		   * automatically spends and returns the asset's owner token (`&NAME!`) so the
+		   * transfer satisfies Neurai consensus (bad-txns-depin-transfer-not-by-owner).
+		   * The owner token is returned to the change address (authority stays with the
+		   * sender). For non-DePIN assets no owner token is involved.
+		   *
+		   * @param {object} params - Transfer parameters
+		   * @param {string} params.assetName - Asset to transfer (e.g. 'TOKEN', '$SEC', '&DEVICE')
+		   * @param {Array<object>} params.recipients - Recipients
+		   * @param {string} params.recipients[].address - Destination address
+		   * @param {number} params.recipients[].amount - Amount in asset display units (> 0)
+		   * @param {string} [params.changeAddress] - Override change/owner-return address
+		   * @returns {Promise<object>} Transaction data
+		   */
+		  async transferAsset(params) {
+		    const builder = new TransferBuilder(this.rpc, this._buildParams(params));
+		    return await builder.build();
+		  }
+
 		  // ========================================
 		  // UNIQUE ASSET (NFT) OPERATIONS
 		  // ========================================