@neuraiproject/neurai-assets 1.0.2 → 1.1.1

package/README.md

@@ -5,11 +5,12 @@ Complete asset management library for Neurai blockchain. Supports creation, reis
 ## Features
 
 - ✅ **Non-custodial**: Library builds unsigned transactions, your wallet signs them
-- ✅ **All asset types**: ROOT, SUB, UNIQUE (NFTs), QUALIFIER, RESTRICTED
+- ✅ **All asset types**: ROOT, SUB, UNIQUE (NFTs), QUALIFIER, RESTRICTED, DEPIN
 - ✅ **Complete operations**: Creation, reissuance, tagging, freezing
 - ✅ **RPC queries**: Complete wrapper for all asset query methods
 - ✅ **Client-side validation**: Prevents errors before creating transactions
 - ✅ **Owner token protection**: Validation to prevent permanent loss
+- ✅ **PQ-ready networks**: Supports `xna-pq` and `xna-pq-test` with `nq1...` / `tnq1...` addresses
 
 ## Supported Asset Types
 
@@ -21,6 +22,7 @@ Complete asset management library for Neurai blockchain. Supports creation, reis
 | **QUALIFIER** | `#KYC` | 2000 XNA | Compliance tag |
 | **SUB_QUALIFIER** | `#PARENT/#SUB` | 200 XNA | Sub-qualifier |
 | **RESTRICTED** | `$SECURITY` | 3000 XNA | Security token with compliance |
+| **DEPIN** | `&DEVICE` or `&DEVICE/ROUTER001` | 10 XNA | Soulbound asset with holder validity controls |
 
 ## Installation
 
@@ -54,6 +56,17 @@ const signedTx = await wallet.signTransaction(result.rawTx);
 const txid = await wallet.broadcastTransaction(signedTx);
 ```
 
+You can also initialize the library with PQ networks and addresses:
+
+```javascript
+const assetsPQ = new NeuraiAssets(rpc, {
+  network: 'xna-pq',                 // or 'xna-pq-test'
+  addresses: ['nq1yourpqaddress...'],
+  changeAddress: 'nq1yourpqchange...',
+  toAddress: 'nq1recipientpqaddress...'
+});
+```
+
 ## Operation Examples
 
 ### Create ROOT Asset
@@ -93,6 +106,20 @@ const result = await assets.reissueAsset({
 });
 ```
 
+### Create DEPIN Asset
+
+```javascript
+const result = await assets.createDepinAsset({
+  assetName: '&DEVICE/ROUTER001',
+  quantity: 1,
+  reissuable: false,
+  hasIpfs: false
+});
+```
+
+> **Note**: DEPIN assets always use `units = 0`. The library accepts both legacy
+> and PQ addresses as recipients depending on the configured network.
+
 ### Create UNIQUE Assets (NFTs)
 
 ```javascript
@@ -319,6 +346,30 @@ const exists = await assets.assetExists('MYTOKEN');
 console.log(exists); // true/false
 ```
 
+### View DEPIN Holders
+
+```javascript
+const holders = await assets.listDepinHolders('&DEVICE/ROUTER001');
+console.log(holders);
+// [
+//   { address: 'nq1holder...', amount: 1, valid: 1 },
+//   { address: 'nq1holder2...', amount: 1, valid: 0 }
+// ]
+```
+
+### Check DEPIN Validity for an Address
+
+```javascript
+const validity = await assets.checkDepinValidity('&DEVICE/ROUTER001', 'nq1holder...');
+console.log(validity);
+// {
+//   has_asset: true,
+//   amount: 1,
+//   valid: 1,
+//   blocked: false
+// }
+```
+
 ### Detect Asset Type
 
 ```javascript
@@ -327,7 +378,8 @@ const type2 = assets.getAssetType('PARENT/SUB');    // 'SUB'
 const type3 = assets.getAssetType('TOKEN#NFT');     // 'UNIQUE'
 const type4 = assets.getAssetType('#KYC');          // 'QUALIFIER'
 const type5 = assets.getAssetType('$SECURITY');     // 'RESTRICTED'
-const type6 = assets.getAssetType('MYTOKEN!');      // 'OWNER'
+const type6 = assets.getAssetType('&DEVICE/ONE');   // 'DEPIN'
+const type7 = assets.getAssetType('MYTOKEN!');      // 'OWNER'
 ```
 
 ## Transaction Result Structure
@@ -337,15 +389,14 @@ All creation/reissuance operations return an object with this structure:
 ```javascript
 {
   rawTx: 'hex string',           // Unsigned transaction (to sign with wallet)
+  utxos: [...],                  // UTXOs selected for the operation
   inputs: [...],                  // Transaction inputs
-  outputs: {...},                 // Ordered outputs
+  outputs: [...],                 // Ordered outputs
   fee: 0.001,                     // Fee in XNA
-  burn: 1000,                     // Burned amount in XNA
-  metadata: {                     // Operation-specific metadata
-    assetName: 'MYTOKEN',
-    ownerTokenName: 'MYTOKEN!',
-    operationType: 'ISSUE_ROOT'
-  }
+  burnAmount: 1000,               // Burned amount in XNA
+  assetName: 'MYTOKEN',           // Operation-specific fields vary by builder
+  ownerTokenName: 'MYTOKEN!',
+  operationType: 'ISSUE_ROOT'
 }
 ```
 
@@ -358,6 +409,7 @@ When you create an asset, an **owner token** is automatically generated (e.g., `
 - Create SUB assets
 - Manage tags (if qualifier)
 - Freeze/unfreeze (if restricted)
+- Manage DEPIN reissuance and controls (if depin)
 
 ⚠️ **If you lose the owner token, you lose these capabilities PERMANENTLY**
 
@@ -378,7 +430,9 @@ The library automatically validates that the owner token is returned in each ope
 | Create QUALIFIER (root) | 2000 |
 | Create QUALIFIER (sub) | 200 |
 | Create RESTRICTED asset | 3000 |
+| Create DEPIN asset | 10 |
 | Reissue ROOT/SUB | 200 |
+| Reissue DEPIN | 200 |
 | Reissue RESTRICTED | 200 |
 | Tag/Untag address | 0.1 (per address) |
 | Freeze/Unfreeze address | 0 (network fee only) |
@@ -415,11 +469,37 @@ const assets = new NeuraiAssets(rpc, {
 const assets = new NeuraiAssets(rpc, {
   network: 'xna-test',
   addresses: [...],
-  changeAddress: 'm...' // or 'n...'
-  toAddress: 'm...'
+  changeAddress: 't...',
+  toAddress: 't...'
+});
+
+// PQ Mainnet
+const assetsPQ = new NeuraiAssets(rpc, {
+  network: 'xna-pq',
+  addresses: ['nq1...'],
+  changeAddress: 'nq1...',
+  toAddress: 'nq1...'
+});
+
+// PQ Testnet
+const assetsPQTest = new NeuraiAssets(rpc, {
+  network: 'xna-pq-test',
+  addresses: ['tnq1...'],
+  changeAddress: 'tnq1...',
+  toAddress: 'tnq1...'
 });
 ```
 
+The library accepts these network names:
+
+- `xna`: legacy/mainnet address flow (`N...`)
+- `xna-test`: legacy/testnet address flow (`t...`)
+- `xna-pq`: PQ mainnet address flow (`nq1...`)
+- `xna-pq-test`: PQ testnet address flow (`tnq1...`)
+
+If you need to derive PQ addresses, use `neurai-key` and pass the resulting `nq1...`
+or `tnq1...` addresses into this library.
+
 ## Update Configuration
 
 ```javascript
@@ -449,6 +529,17 @@ const builder = new builders.IssueRootBuilder(rpc, {
 const result = await builder.build();
 ```
 
+The builders module also includes:
+
+- `IssueDepinBuilder`
+- `IssueRootBuilder`
+- `IssueSubBuilder`
+- `IssueUniqueBuilder`
+- `IssueQualifierBuilder`
+- `IssueRestrictedBuilder`
+- `ReissueBuilder`
+- `ReissueRestrictedBuilder`
+
 ## Error Handling
 
 The library throws specific errors:
@@ -524,4 +615,8 @@ const signedTx = await wallet.signTransaction(result.rawTx);
 // Broadcast
 const txid = await wallet.broadcastTransaction(signedTx);
 console.log('Transaction ID:', txid);
-```
+```
+
+For PQ wallets, derive addresses externally with `neurai-key` using `xna-pq` or
+`xna-pq-test`, then initialize `NeuraiAssets` with those addresses and the matching
+network name.

package/examples/10-depin-post-quantum.js

@@ -0,0 +1,83 @@
+/**
+ * Example: DEPIN Assets with Post-Quantum Addresses
+ *
+ * This example demonstrates how to use DEPIN assets with PQ addresses
+ * generated by neurai-key using the xna-pq / xna-pq-test networks.
+ *
+ * PQ address examples:
+ * - Mainnet: nq1...
+ * - Testnet: tnq1...
+ */
+
+const NeuraiAssets = require('@neuraiproject/neurai-assets');
+
+async function createDepinForPQAddress() {
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+    // Replace with your actual RPC client
+  };
+
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna-pq',                          // Or 'xna-pq-test'
+    addresses: ['nq1yourpqwalletaddress...'],   // PQ addresses from neurai-key
+    changeAddress: 'nq1yourpqchangeaddress...',
+    toAddress: 'nq1recipientpqaddress...'
+  });
+
+  try {
+    const result = await assets.createDepinAsset({
+      assetName: '&DEVICE/ROUTER001',
+      quantity: 1,
+      reissuable: false
+    });
+
+    console.log('DEPIN transaction created');
+    console.log('Raw transaction:', result.rawTx);
+    console.log('Burn:', result.burnAmount, 'XNA');
+    console.log('Owner token:', result.ownerTokenName);
+  } catch (error) {
+    console.error('Error creating DEPIN asset for PQ address:', error.message);
+  }
+}
+
+async function queryDepinValidityForPQAddress() {
+  const rpc = async (method, params) => {
+    console.log(`RPC Call: ${method}`, params);
+
+    if (method === 'checkdepinvalidity') {
+      return {
+        has_asset: true,
+        amount: 1,
+        valid: 1,
+        blocked: false
+      };
+    }
+
+    if (method === 'listdepinholders') {
+      return [
+        { address: 'nq1firstholder...', amount: 1, valid: 1 },
+        { address: 'nq1secondholder...', amount: 1, valid: 0 }
+      ];
+    }
+  };
+
+  const assets = new NeuraiAssets(rpc, {
+    network: 'xna-pq',
+    addresses: ['nq1yourpqwalletaddress...'],
+    changeAddress: 'nq1yourpqchangeaddress...',
+    toAddress: 'nq1recipientpqaddress...'
+  });
+
+  try {
+    const validity = await assets.checkDepinValidity('&DEVICE/ROUTER001', 'nq1recipientpqaddress...');
+    console.log('DEPIN validity for PQ address:', validity);
+
+    const holders = await assets.listDepinHolders('&DEVICE/ROUTER001');
+    console.log('DEPIN holders:', holders);
+  } catch (error) {
+    console.error('Error querying DEPIN PQ data:', error.message);
+  }
+}
+
+createDepinForPQAddress();
+queryDepinValidityForPQAddress();

package/examples/README.md

@@ -163,6 +163,23 @@ Learn complete integration with `@neuraiproject/neurai-jswallet`.
 
 ---
 
+### 10. DEPIN with Post-Quantum Addresses
+**File:** [10-depin-post-quantum.js](10-depin-post-quantum.js)
+
+Learn how to use DEPIN assets with PQ addresses generated by `neurai-key`.
+
+- PQ mainnet network: `xna-pq`
+- PQ testnet network: `xna-pq-test`
+- PQ address formats: `nq1...` and `tnq1...`
+
+**Topics covered:**
+- Initializing `NeuraiAssets` with PQ networks
+- Creating DEPIN assets sent to PQ addresses
+- Querying DEPIN validity for PQ holders
+- Listing DEPIN holders with PQ addresses
+
+---
+
 ## Running the Examples
 
 ### Prerequisites
@@ -184,9 +201,9 @@ node 01-create-root-asset.js
 
 1. **Mock RPC**: All examples use mock RPC functions. Replace with your actual RPC client in production.
 
-2. **Network**: Examples use mainnet (`'xna'`). Change to `'xna-test'` for testnet.
+2. **Network**: Examples use mainnet (`'xna'`). Change to `'xna-test'` for testnet. PQ networks are `xna-pq` and `xna-pq-test`.
 
-3. **Addresses**: Replace placeholder addresses with your actual wallet addresses.
+3. **Addresses**: Replace placeholder addresses with your actual wallet addresses. PQ examples use `nq1...` / `tnq1...` addresses.
 
 4. **Testing**: Test on testnet first before using mainnet.
 
@@ -232,6 +249,7 @@ const txid = await wallet.broadcastTransaction(signedTx);
 | QUALIFIER | `#NAME` | 2000 XNA | `#KYC_VERIFIED` |
 | SUB_QUALIFIER | `#ROOT/#SUB` | 200 XNA | `#KYC/#LEVEL2` |
 | RESTRICTED | `$NAME` | 3000 XNA | `$SECURITY` |
+| DEPIN | `&NAME` or `&ROOT/SUB` | 10 XNA | `&DEVICE/ROUTER001` |
 | OWNER | `NAME!` | N/A | `MYTOKEN!` |
 
 ## Common Patterns

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuraiproject/neurai-assets",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Non-custodial Neurai asset management library for JavaScript",
   "main": "./src/index.js",
   "scripts": {
@@ -29,13 +29,16 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {},
   "devDependencies": {
     "chai": "^4.3.10",
-    "mocha": "^10.2.0"
+    "mocha": "^11.7.5"
+  },
+  "overrides": {
+    "diff": "8.0.4",
+    "serialize-javascript": "7.0.5"
   },
   "peerDependencies": {
-    "@neuraiproject/neurai-rpc": "^0.4.6"
+    "@neuraiproject/neurai-rpc": "^0.4.7"
   },
   "engines": {
     "node": ">=14.0.0"

package/src/NeuraiAssets.js

@@ -25,6 +25,7 @@ const { AssetQueries } = require('./queries');
 const {
   IssueRootBuilder,
   IssueSubBuilder,
+  IssueDepinBuilder,
   IssueUniqueBuilder,
   IssueQualifierBuilder,
   IssueRestrictedBuilder,
@@ -119,6 +120,21 @@ class NeuraiAssets {
     return await builder.build();
   }
 
+  /**
+   * Create a DEPIN asset
+   * @param {object} params - DEPIN creation parameters
+   * @param {string} params.assetName - Asset name (&NAME or &NAME/SUB)
+   * @param {number} params.quantity - Total supply
+   * @param {boolean} [params.reissuable=true] - Can mint more later
+   * @param {boolean} [params.hasIpfs=false] - Has IPFS metadata
+   * @param {string} [params.ipfsHash] - IPFS hash
+   * @returns {Promise<object>} Transaction data
+   */
+  async createDepinAsset(params) {
+    const builder = new IssueDepinBuilder(this.rpc, this._buildParams(params));
+    return await builder.build();
+  }
+
   /**
    * Reissue (mint more) of a ROOT or SUB asset
    * @param {object} params - Reissue parameters
@@ -439,6 +455,25 @@ class NeuraiAssets {
     return await this.queries.cancelSnapshotRequest(assetName, blockHeight);
   }
 
+  /**
+   * List DEPIN holders with validity status
+   * @param {string} assetName - DEPIN asset name
+   * @returns {Promise<Array>} Holder entries
+   */
+  async listDepinHolders(assetName) {
+    return await this.queries.listDepinHolders(assetName);
+  }
+
+  /**
+   * Check DEPIN validity for an address
+   * @param {string} assetName - DEPIN asset name
+   * @param {string} address - Address to query
+   * @returns {Promise<object>} Validity details
+   */
+  async checkDepinValidity(assetName, address) {
+    return await this.queries.checkDepinValidity(assetName, address);
+  }
+
   /**
    * Check if asset exists
    * @param {string} assetName - Asset name
@@ -451,7 +486,7 @@ class NeuraiAssets {
   /**
    * Get asset type from name
    * @param {string} assetName - Asset name
-   * @returns {string} Asset type ('ROOT', 'SUB', 'UNIQUE', 'QUALIFIER', 'RESTRICTED', 'OWNER')
+   * @returns {string} Asset type ('ROOT', 'SUB', 'UNIQUE', 'QUALIFIER', 'RESTRICTED', 'DEPIN', 'OWNER')
    */
   getAssetType(assetName) {
     return this.queries.getAssetType(assetName);

package/src/builders/BaseAssetTransactionBuilder.js

@@ -225,6 +225,9 @@ class BaseAssetTransactionBuilder {
       case 'RESTRICTED':
         AssetNameValidator.validateRestricted(assetName);
         break;
+      case 'DEPIN':
+        AssetNameValidator.validateDepin(assetName);
+        break;
       default:
         throw new Error(`Unknown asset type: ${type}`);
     }

package/src/builders/IssueDepinBuilder.js

@@ -0,0 +1,144 @@
+/**
+ * Issue DePIN Builder
+ * Builds transactions for creating DEPIN assets.
+ *
+ * DEPIN assets:
+ * - Soulbound assets
+ * - Format: &NAME or &NAME/SUB
+ * - Cost: 10 XNA (same burn as UNIQUE assets)
+ * - Units: Always 0
+ * - Owner token is auto-created by the node
+ */
+
+const BaseAssetTransactionBuilder = require('./BaseAssetTransactionBuilder');
+const { OutputFormatter } = require('../utils');
+const { AssetExistsError } = require('../errors');
+const { IpfsValidator } = require('../validators');
+
+class IssueDepinBuilder extends BaseAssetTransactionBuilder {
+  /**
+   * Validate issue DEPIN parameters
+   * @param {object} params - Issue parameters
+   * @throws {Error} If validation fails
+   */
+  validateParams(params) {
+    if (!params.assetName) {
+      throw new Error('assetName is required');
+    }
+
+    if (params.quantity === undefined || params.quantity === null) {
+      throw new Error('quantity is required');
+    }
+
+    this.validateAssetName(params.assetName, 'DEPIN');
+    this.validateAmount(params.quantity, 0);
+
+    if (params.units !== undefined && params.units !== 0) {
+      throw new Error('DEPIN assets must use units=0');
+    }
+
+    if (params.hasIpfs && params.ipfsHash) {
+      IpfsValidator.validate(params.ipfsHash);
+    }
+
+    if (params.reissuable !== undefined && typeof params.reissuable !== 'boolean') {
+      throw new Error('reissuable must be a boolean');
+    }
+
+    return true;
+  }
+
+  /**
+   * Build DEPIN asset issuance transaction
+   * @returns {Promise<object>} Transaction result
+   */
+  async build() {
+    await this.validateParams(this.params);
+
+    const {
+      assetName,
+      quantity,
+      reissuable = true,
+      hasIpfs = false,
+      ipfsHash = ''
+    } = this.params;
+
+    const exists = await this.assetExists(assetName);
+    if (exists) {
+      throw new AssetExistsError(
+        `Asset ${assetName} already exists on the blockchain`,
+        assetName
+      );
+    }
+
+    const burnInfo = this.burnManager.getIssueDepinBurn();
+    const toAddress = await this.getToAddress();
+    const changeAddress = await this.getChangeAddress();
+
+    const estimatedFee = await this.estimateFee(1, 3);
+    const totalXNANeeded = burnInfo.amount + estimatedFee;
+
+    const utxoSelection = await this.selectUTXOs(totalXNANeeded, null, 0);
+    const baseCurrencyUTXOs = utxoSelection.xnaUTXOs;
+    const totalXNAInput = utxoSelection.totalXNA;
+
+    const actualFee = await this.estimateFee(baseCurrencyUTXOs.length, 3);
+    const totalRequired = burnInfo.amount + actualFee;
+
+    if (totalXNAInput < totalRequired) {
+      const additionalNeeded = totalRequired - totalXNAInput + 0.001;
+      const additionalSelection = await this.selectUTXOs(additionalNeeded, null, 0);
+      baseCurrencyUTXOs.push(...additionalSelection.xnaUTXOs);
+    }
+
+    const finalTotalInput = baseCurrencyUTXOs.reduce(
+      (sum, utxo) => sum + utxo.satoshis / 100000000,
+      0
+    );
+    const xnaChange = finalTotalInput - burnInfo.amount - actualFee;
+
+    const inputs = baseCurrencyUTXOs.map(utxo => ({
+      txid: utxo.txid,
+      vout: utxo.outputIndex,
+      address: utxo.address,
+      satoshis: utxo.satoshis
+    }));
+
+    const outputs = [];
+    outputs.push({ [burnInfo.address]: burnInfo.amount });
+
+    if (xnaChange > 0.00000001) {
+      outputs.push({ [changeAddress]: parseFloat(xnaChange.toFixed(8)) });
+    }
+
+    const issueOutput = OutputFormatter.formatIssueOutput({
+      asset_name: assetName,
+      asset_quantity: this.toSatoshis(quantity, 0),
+      units: 0,
+      reissuable,
+      has_ipfs: hasIpfs,
+      ipfs_hash: ipfsHash
+    });
+
+    outputs.push({ [toAddress]: issueOutput });
+
+    const orderedOutputs = this.outputOrderer.order(outputs);
+    const rawTx = await this.buildRawTransaction(inputs, orderedOutputs);
+
+    return this.formatResult(
+      rawTx,
+      baseCurrencyUTXOs,
+      inputs,
+      orderedOutputs,
+      actualFee,
+      burnInfo.amount,
+      {
+        assetName,
+        ownerTokenName: `${assetName}!`,
+        operationType: 'ISSUE_DEPIN'
+      }
+    );
+  }
+}
+
+module.exports = IssueDepinBuilder;

package/src/builders/ReissueBuilder.js

@@ -103,6 +103,7 @@ class ReissueBuilder extends BaseAssetTransactionBuilder {
     const addresses = await this._getAddresses();
     const toAddress = await this.getToAddress();
     const changeAddress = await this.getChangeAddress();
+    const isDepinAsset = AssetNameParser.isDepin(assetName);
 
     // 6. Find owner token (CRITICAL: must have this)
     const ownerTokenName = AssetNameParser.getOwnerTokenName(assetName);
@@ -201,7 +202,7 @@ class ReissueBuilder extends BaseAssetTransactionBuilder {
       asset_quantity: this.toSatoshis(quantity, units),
       reissuable: reissuable !== undefined ? reissuable : undefined,
       new_ipfs: newIpfs || undefined,
-      owner_change_address: changeAddress
+      owner_change_address: isDepinAsset ? toAddress : changeAddress
     });
 
     outputs.push({ [toAddress]: reissueOutput });

package/src/builders/index.js

@@ -9,6 +9,7 @@ const BaseAssetTransactionBuilder = require('./BaseAssetTransactionBuilder');
 // Basic Builders
 const IssueRootBuilder = require('./IssueRootBuilder');
 const IssueSubBuilder = require('./IssueSubBuilder');
+const IssueDepinBuilder = require('./IssueDepinBuilder');
 const ReissueBuilder = require('./ReissueBuilder');
 
 // Advanced Builders
@@ -26,6 +27,7 @@ module.exports = {
   // Basic Builders
   IssueRootBuilder,
   IssueSubBuilder,
+  IssueDepinBuilder,
   ReissueBuilder,
 
   // Advanced Builders

package/src/constants/burnAddresses.js

@@ -3,6 +3,21 @@
  * Different addresses for mainnet and testnet
  */
 
+const MAINNET_NETWORKS = ['xna', 'mainnet', 'xna-pq', 'mainnet-pq'];
+const TESTNET_NETWORKS = ['xna-test', 'testnet', 'regtest', 'xna-pq-test', 'testnet-pq'];
+
+function resolveNetworkFamily(network) {
+  if (MAINNET_NETWORKS.includes(network)) {
+    return 'mainnet';
+  }
+
+  if (TESTNET_NETWORKS.includes(network)) {
+    return 'testnet';
+  }
+
+  throw new Error(`Unknown network: ${network}`);
+}
+
 const MAINNET_BURN_ADDRESSES = {
   ISSUE_ROOT: 'NbURNXXXXXXXXXXXXXXXXXXXXXXXT65Gdr',
   ISSUE_SUB: 'NXissueSubAssetXXXXXXXXXXXXXX6B2JF',
@@ -32,11 +47,12 @@ const TESTNET_BURN_ADDRESSES = {
 /**
  * Get burn address for an operation and network
  * @param {string} operationType - Operation type (e.g., 'ISSUE_ROOT')
- * @param {string} network - Network type ('xna' or 'xna-test')
+ * @param {string} network - Network type ('xna', 'xna-test', 'xna-pq', or 'xna-pq-test')
  * @returns {string} Burn address
  */
 function getBurnAddress(operationType, network) {
-  const addresses = network === 'xna' ? MAINNET_BURN_ADDRESSES : TESTNET_BURN_ADDRESSES;
+  const family = resolveNetworkFamily(network);
+  const addresses = family === 'mainnet' ? MAINNET_BURN_ADDRESSES : TESTNET_BURN_ADDRESSES;
 
   const address = addresses[operationType];
   if (!address) {
@@ -49,17 +65,19 @@ function getBurnAddress(operationType, network) {
 /**
  * Check if an address is a burn address
  * @param {string} address - Address to check
- * @param {string} network - Network type ('xna' or 'xna-test')
+ * @param {string} network - Network type ('xna', 'xna-test', 'xna-pq', or 'xna-pq-test')
  * @returns {boolean} True if it's a burn address
  */
 function isBurnAddress(address, network) {
-  const addresses = network === 'xna' ? MAINNET_BURN_ADDRESSES : TESTNET_BURN_ADDRESSES;
+  const family = resolveNetworkFamily(network);
+  const addresses = family === 'mainnet' ? MAINNET_BURN_ADDRESSES : TESTNET_BURN_ADDRESSES;
   return Object.values(addresses).includes(address);
 }
 
 module.exports = {
   MAINNET_BURN_ADDRESSES,
   TESTNET_BURN_ADDRESSES,
+  resolveNetworkFamily,
   getBurnAddress,
   isBurnAddress
 };

package/src/constants/index.js

@@ -8,6 +8,7 @@ const { ASSET_COSTS, getAssetCost, getUniqueAssetCost, getTaggingCost } = requir
 const {
   MAINNET_BURN_ADDRESSES,
   TESTNET_BURN_ADDRESSES,
+  resolveNetworkFamily,
   getBurnAddress,
   isBurnAddress
 } = require('./burnAddresses');
@@ -32,6 +33,7 @@ module.exports = {
   // Burn Addresses
   MAINNET_BURN_ADDRESSES,
   TESTNET_BURN_ADDRESSES,
+  resolveNetworkFamily,
   getBurnAddress,
   isBurnAddress,