@chainvue/verus-sdk 0.4.0

package/dist/identity/index.js

@@ -0,0 +1,691 @@
+"use strict";
+/**
+ * Identity transaction building utilities and workflows
+ *
+ * Handles:
+ * - Name commitment (Step 1 of identity creation)
+ * - Identity registration (Step 2)
+ * - Identity updates (modify, revoke, recover, lock, unlock)
+ * - Script/hash construction for CC outputs
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameAndParentAddrToIAddr = void 0;
+exports.generateSalt = generateSalt;
+exports.serializeNameReservation = serializeNameReservation;
+exports.serializeAdvancedNameReservation = serializeAdvancedNameReservation;
+exports.calculateCommitmentHash = calculateCommitmentHash;
+exports.serializeCommitmentHash = serializeCommitmentHash;
+exports.buildCommitmentScript = buildCommitmentScript;
+exports.buildReservationScript = buildReservationScript;
+exports.buildIdentityScript = buildIdentityScript;
+exports.deriveIdentityAddress = deriveIdentityAddress;
+exports.isVRSCParent = isVRSCParent;
+exports.prepareNameCommitment = prepareNameCommitment;
+exports.buildP2IDScript = buildP2IDScript;
+exports.identityPaymentScript = identityPaymentScript;
+exports.buildReferralPaymentScript = buildReferralPaymentScript;
+exports.calculateRegistrationFees = calculateRegistrationFees;
+exports.createIdentityObject = createIdentityObject;
+exports.buildRegistrationFeeOutput = buildRegistrationFeeOutput;
+exports.buildTokenChangeOutput = buildTokenChangeOutput;
+exports.buildAndSignCommitment = buildAndSignCommitment;
+exports.buildAndSignRegistration = buildAndSignRegistration;
+exports.buildAndSignIdentityUpdate = buildAndSignIdentityUpdate;
+const crypto_1 = require("crypto");
+const bn_js_1 = __importDefault(require("bn.js"));
+const verus_typescript_primitives_1 = require("verus-typescript-primitives");
+const verus_typescript_primitives_2 = require("verus-typescript-primitives");
+const verus_typescript_primitives_3 = require("verus-typescript-primitives");
+Object.defineProperty(exports, "nameAndParentAddrToIAddr", { enumerable: true, get: function () { return verus_typescript_primitives_3.nameAndParentAddrToIAddr; } });
+const utxo_lib_1 = require("@bitgo/utxo-lib");
+const index_js_1 = require("../constants/index.js");
+const index_js_2 = require("../utils/index.js");
+const index_js_3 = require("../signing/index.js");
+const index_js_4 = require("../utxo/index.js");
+const errors_js_1 = require("../errors.js");
+const index_js_5 = require("../keys/index.js");
+const { createUnfundedIdentityUpdate, completeFundedIdentityUpdate } = utxo_lib_1.smarttxs;
+const HASH160_BYTE_LENGTH = 20;
+const HASH256_BYTE_LENGTH = 32;
+/** Null identity hash (20 zero bytes) */
+const NULL_ID_HASH = Buffer.alloc(HASH160_BYTE_LENGTH, 0);
+/** Eval code for CAdvancedNameReservation (sub-ID) */
+const EVAL_IDENTITY_ADVANCEDRESERVATION = 10;
+// ─── Script / Hash Builders ────────────────────────────────────────
+/**
+ * Generate a random 32-byte salt for name commitment
+ */
+function generateSalt() {
+    return (0, crypto_1.randomBytes)(HASH256_BYTE_LENGTH);
+}
+/**
+ * Serialize a CNameReservation (for VRSC-parent identities)
+ */
+function serializeNameReservation(name, referralHash, salt) {
+    const nameBytes = Buffer.from(name, 'utf8');
+    const compactSize = (0, index_js_2.writeCompactSize)(nameBytes.length);
+    return Buffer.concat([compactSize, nameBytes, referralHash, salt]);
+}
+/**
+ * Serialize a CAdvancedNameReservation (for PBaaS-parent identities)
+ */
+function serializeAdvancedNameReservation(version, name, parentHash, referralHash, salt) {
+    const nameBytes = Buffer.from(name, 'utf8');
+    const compactSize = (0, index_js_2.writeCompactSize)(nameBytes.length);
+    const versionBuf = Buffer.alloc(4);
+    versionBuf.writeUInt32LE(version, 0);
+    return Buffer.concat([versionBuf, compactSize, nameBytes, parentHash, referralHash, salt]);
+}
+/**
+ * Calculate the commitment hash from a serialized name reservation
+ */
+function calculateCommitmentHash(serializedReservation) {
+    return (0, index_js_2.sha256d)(serializedReservation);
+}
+/**
+ * Serialize a CCommitmentHash
+ */
+function serializeCommitmentHash(hash) {
+    const tokenOutput = new verus_typescript_primitives_1.TokenOutput({
+        version: new bn_js_1.default(0),
+        values: new verus_typescript_primitives_1.CurrencyValueMap(),
+    });
+    const tokenBuf = tokenOutput.toBuffer();
+    return Buffer.concat([tokenBuf, hash]);
+}
+/**
+ * Build the commitment output script
+ */
+function buildCommitmentScript(commitmentHashBuf, controlAddress) {
+    const controlDest = new verus_typescript_primitives_1.TxDestination(verus_typescript_primitives_1.KeyID.fromAddress(controlAddress));
+    const master = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_NONE),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [controlDest],
+        vdata: [],
+    });
+    const params = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_IDENTITY_COMMITMENT),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [controlDest],
+        vdata: [commitmentHashBuf],
+    });
+    const script = new verus_typescript_primitives_1.SmartTransactionScript(master, params);
+    return script.toBuffer();
+}
+/**
+ * Build the name reservation output script
+ */
+function buildReservationScript(newIdentityIAddress, serializedReservation, isAdvanced = false) {
+    const identityDest = new verus_typescript_primitives_1.TxDestination(verus_typescript_primitives_1.IdentityID.fromAddress(newIdentityIAddress));
+    const evalCode = isAdvanced
+        ? EVAL_IDENTITY_ADVANCEDRESERVATION
+        : verus_typescript_primitives_2.EVALS.EVAL_IDENTITY_RESERVATION;
+    const master = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_NONE),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [identityDest],
+        vdata: [],
+    });
+    const params = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(evalCode),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [identityDest],
+        vdata: [serializedReservation],
+    });
+    const script = new verus_typescript_primitives_1.SmartTransactionScript(master, params);
+    return script.toBuffer();
+}
+/**
+ * Build an identity definition output script from an Identity object
+ */
+function buildIdentityScript(identity) {
+    const identityScript = verus_typescript_primitives_1.IdentityScript.fromIdentity(identity);
+    return identityScript.toBuffer();
+}
+/**
+ * Derive the identity i-address from a name and optional parent
+ */
+function deriveIdentityAddress(name, parentIAddress) {
+    return (0, verus_typescript_primitives_3.nameAndParentAddrToIAddr)(name, parentIAddress || undefined);
+}
+/**
+ * Determine if a parent is the VRSC root system
+ */
+function isVRSCParent(parentIAddress, network = 'mainnet') {
+    if (!parentIAddress)
+        return true;
+    const systemId = index_js_1.NETWORK_CONFIG[network].chainId;
+    return parentIAddress === systemId;
+}
+/**
+ * Build the full commitment data needed for Step 1 of identity creation
+ */
+function prepareNameCommitment(name, controlAddress, referralIAddress, parentIAddress, network = 'mainnet') {
+    const salt = generateSalt();
+    const systemId = index_js_1.NETWORK_CONFIG[network].chainId;
+    const referralHash = referralIAddress
+        ? (0, index_js_2.iAddressToHash)(referralIAddress)
+        : NULL_ID_HASH;
+    const effectiveParent = parentIAddress && parentIAddress !== systemId
+        ? parentIAddress
+        : undefined;
+    const identityAddress = deriveIdentityAddress(name, effectiveParent || systemId);
+    let serializedReservation;
+    if (isVRSCParent(parentIAddress, network)) {
+        serializedReservation = serializeNameReservation(name, referralHash, salt);
+    }
+    else {
+        const parentHash = parentIAddress
+            ? (0, index_js_2.iAddressToHash)(parentIAddress)
+            : NULL_ID_HASH;
+        serializedReservation = serializeAdvancedNameReservation(1, name, parentHash, referralHash, salt);
+    }
+    const commitmentHash = calculateCommitmentHash(serializedReservation);
+    const serializedCommitmentHash = serializeCommitmentHash(commitmentHash);
+    const commitmentScript = buildCommitmentScript(commitmentHash, controlAddress);
+    return {
+        salt,
+        serializedReservation,
+        commitmentHash,
+        serializedCommitmentHash,
+        commitmentScript,
+        identityAddress,
+    };
+}
+/**
+ * Build a P2ID output script (pay to identity)
+ */
+function buildP2IDScript(iAddress) {
+    const idHash = (0, index_js_2.iAddressToHash)(iAddress);
+    return utxo_lib_1.script.compile([
+        utxo_lib_1.opcodes.OP_DUP,
+        utxo_lib_1.opcodes.OP_HASH160,
+        idHash,
+        utxo_lib_1.opcodes.OP_EQUALVERIFY,
+        utxo_lib_1.opcodes.OP_CHECKSIG,
+        utxo_lib_1.opcodes.OP_CHECKCRYPTOCONDITION,
+    ]);
+}
+/**
+ * The standard pay-to-identity output script (CC EVAL_NONE 1-of-1 to an
+ * IdentityID) — byte-identical to what the chain itself produces when paying
+ * an identity (verified against on-chain P2ID outputs). Use this for change
+ * or payment outputs to an i-address.
+ */
+function identityPaymentScript(iAddress) {
+    return buildReferralPaymentScript(iAddress);
+}
+/**
+ * Build a CC referral payment output script
+ */
+function buildReferralPaymentScript(iAddress) {
+    const identityDest = new verus_typescript_primitives_1.TxDestination(verus_typescript_primitives_1.IdentityID.fromAddress(iAddress));
+    // Master: EVAL_NONE outputs have empty master (no index destinations)
+    // This matches the daemon's MakeMofNCCScript for EVAL_NONE condition objects
+    const master = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_NONE),
+        m: new bn_js_1.default(0),
+        n: new bn_js_1.default(0),
+        destinations: [],
+        vdata: [],
+    });
+    const params = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_NONE),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [identityDest],
+        vdata: [],
+    });
+    const script = new verus_typescript_primitives_1.SmartTransactionScript(master, params);
+    return script.toBuffer();
+}
+/**
+ * Calculate registration fee breakdown
+ */
+function calculateRegistrationFees(hasReferral, totalFee = index_js_1.DEFAULT_REGISTRATION_FEE, referralLevels = index_js_1.DEFAULT_REFERRAL_LEVELS) {
+    if (!hasReferral) {
+        return { issuerFee: totalFee, referralAmount: 0, totalRequired: totalFee };
+    }
+    const issuerFee = Math.floor(totalFee * (referralLevels + 1) / (referralLevels + 2));
+    const referralAmount = Math.floor(totalFee / (referralLevels + 2));
+    const totalRequired = issuerFee + referralAmount * referralLevels;
+    return { issuerFee, referralAmount, totalRequired };
+}
+/**
+ * Build a new Identity object for registration
+ */
+function createIdentityObject(params) {
+    const primaryKeys = params.primaryAddresses.map(addr => verus_typescript_primitives_1.KeyID.fromAddress(addr));
+    const identity = new verus_typescript_primitives_1.Identity({
+        version: verus_typescript_primitives_1.Identity.VERSION_CURRENT,
+        flags: new bn_js_1.default(0),
+        min_sigs: new bn_js_1.default(params.minSigs || 1),
+        primary_addresses: primaryKeys,
+        parent: verus_typescript_primitives_1.IdentityID.fromAddress(params.parentIAddress),
+        system_id: verus_typescript_primitives_1.IdentityID.fromAddress(params.systemId),
+        name: params.name,
+        revocation_authority: verus_typescript_primitives_1.IdentityID.fromAddress(params.revocationAuthority),
+        recovery_authority: verus_typescript_primitives_1.IdentityID.fromAddress(params.recoveryAuthority),
+        private_addresses: [],
+        unlock_after: new bn_js_1.default(0),
+    });
+    return identity;
+}
+/**
+ * Build a CReserveTransfer fee output for sub-ID registration
+ */
+function buildRegistrationFeeOutput(parentCurrencyId, feeAmount, systemId, _controlAddress) {
+    const destination = new verus_typescript_primitives_1.TxDestination(verus_typescript_primitives_1.KeyID.fromAddress(index_js_1.RESERVE_TRANSFER_EVAL_PKH));
+    const values = new verus_typescript_primitives_1.CurrencyValueMap({
+        value_map: new Map([[parentCurrencyId, new bn_js_1.default(feeAmount)]]),
+        multivalue: false,
+    });
+    const parentHash = (0, verus_typescript_primitives_3.fromBase58Check)(parentCurrencyId).hash;
+    const transferDest = new verus_typescript_primitives_1.TransferDestination({
+        type: verus_typescript_primitives_1.DEST_ID,
+        destination_bytes: Buffer.from(parentHash),
+    });
+    const flags = verus_typescript_primitives_1.RESERVE_TRANSFER_VALID.or(verus_typescript_primitives_1.RESERVE_TRANSFER_BURN_CHANGE_PRICE);
+    const resTransfer = new verus_typescript_primitives_1.ReserveTransfer({
+        values,
+        version: new bn_js_1.default(1),
+        flags,
+        fee_currency_id: systemId,
+        fee_amount: new bn_js_1.default(index_js_1.RESERVE_TRANSFER_FEE),
+        transfer_destination: transferDest,
+        dest_currency_id: parentCurrencyId,
+    });
+    const master = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_NONE),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [destination],
+        vdata: [],
+    });
+    const params = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_RESERVE_TRANSFER),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [destination],
+        vdata: [resTransfer.toBuffer()],
+    });
+    const script = new verus_typescript_primitives_1.SmartTransactionScript(master, params);
+    return { script: script.toBuffer(), nativeValue: index_js_1.RESERVE_TRANSFER_FEE };
+}
+/**
+ * Build a token change output (EVAL_RESERVE_OUTPUT)
+ */
+function buildTokenChangeOutput(changeAddress, currencyChanges) {
+    const destination = new verus_typescript_primitives_1.TxDestination(verus_typescript_primitives_1.KeyID.fromAddress(changeAddress));
+    const valueMap = new Map();
+    for (const [currency, amount] of currencyChanges) {
+        if (amount > 0) {
+            valueMap.set(currency, new bn_js_1.default(amount));
+        }
+    }
+    const values = new verus_typescript_primitives_1.CurrencyValueMap({
+        value_map: valueMap,
+        multivalue: false,
+    });
+    const tokenOutput = new verus_typescript_primitives_1.TokenOutput({ version: new bn_js_1.default(1), values });
+    const master = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_NONE),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [destination],
+        vdata: [],
+    });
+    const params = new verus_typescript_primitives_1.OptCCParams({
+        version: new bn_js_1.default(3),
+        eval_code: new bn_js_1.default(verus_typescript_primitives_2.EVALS.EVAL_RESERVE_OUTPUT),
+        m: new bn_js_1.default(1),
+        n: new bn_js_1.default(1),
+        destinations: [destination],
+        vdata: [tokenOutput.toBuffer()],
+    });
+    const script = new verus_typescript_primitives_1.SmartTransactionScript(master, params);
+    return { script: script.toBuffer(), nativeValue: 0 };
+}
+// ─── Validation ──────────────────────────────────────────────────
+const IDENTITY_NAME_RE = /^[a-z0-9_-]{1,64}$/;
+function validateIdentityWif(wif) {
+    if (!wif || typeof wif !== 'string') {
+        throw new errors_js_1.InvalidWifError('WIF is required');
+    }
+    const check = (0, index_js_5.validateWif)(wif);
+    if (!check.valid) {
+        throw new errors_js_1.InvalidWifError(check.error);
+    }
+}
+function validateIdentityName(name) {
+    if (!name || typeof name !== 'string') {
+        throw new errors_js_1.InvalidNameError('', 'Name is required');
+    }
+    if (!IDENTITY_NAME_RE.test(name)) {
+        throw new errors_js_1.InvalidNameError(name);
+    }
+}
+// ─── Workflow Orchestrators ────────────────────────────────────────
+/**
+ * Build and sign a name commitment transaction (Step 1 of identity creation)
+ */
+function buildAndSignCommitment(params, network) {
+    validateIdentityWif(params.wif);
+    validateIdentityName(params.name);
+    if (!params.utxos || params.utxos.length === 0) {
+        throw new errors_js_1.TransactionBuildError('At least one UTXO is required');
+    }
+    const verusNetwork = (0, index_js_3.getNetwork)(network === 'testnet');
+    const networkConfig = index_js_1.NETWORK_CONFIG[network];
+    const commitment = prepareNameCommitment(params.name, params.changeAddress, params.referral, params.parent, network);
+    const utxos = params.utxos;
+    const selection = (0, index_js_4.selectUtxos)(utxos, 0, new Map(), 1, networkConfig.chainId, undefined, true);
+    const txb = new utxo_lib_1.TransactionBuilder(verusNetwork);
+    txb.setVersion(4);
+    txb.setExpiryHeight(params.expiryHeight || 0);
+    txb.setVersionGroupId(index_js_1.VERSION_GROUP_ID);
+    for (const utxo of selection.selected) {
+        txb.addInput(Buffer.from(utxo.txid, 'hex').reverse(), utxo.outputIndex, 0xffffffff, Buffer.from(utxo.script, 'hex'));
+    }
+    txb.addOutput(commitment.commitmentScript, 0);
+    if (selection.nativeChange > 0) {
+        txb.addOutput(params.changeAddress, selection.nativeChange);
+    }
+    const unsignedTx = txb.buildIncomplete();
+    const { signedTx, txid } = (0, index_js_3.signTransactionSmart)(unsignedTx.toHex(), params.wif, selection.selected, verusNetwork);
+    return {
+        signedTx,
+        txid,
+        fee: selection.fee,
+        identityAddress: commitment.identityAddress,
+        commitmentData: {
+            name: params.name,
+            salt: commitment.salt.toString('hex'),
+            referral: params.referral || null,
+            parent: params.parent || null,
+            namereservationHex: commitment.serializedReservation.toString('hex'),
+            commitmentHash: commitment.commitmentHash.toString('hex'),
+        },
+    };
+}
+/**
+ * Build and sign an identity registration transaction (Step 2)
+ */
+function buildAndSignRegistration(params, network) {
+    validateIdentityWif(params.wif);
+    if (!params.primaryAddresses || params.primaryAddresses.length === 0) {
+        throw new errors_js_1.TransactionBuildError('At least one primary address is required');
+    }
+    if (!params.utxos || params.utxos.length === 0) {
+        throw new errors_js_1.TransactionBuildError('At least one funding UTXO is required');
+    }
+    const verusNetwork = (0, index_js_3.getNetwork)(network === 'testnet');
+    const networkConfig = index_js_1.NETWORK_CONFIG[network];
+    const systemId = networkConfig.chainId;
+    const commitData = params.commitmentData;
+    const parentIAddress = commitData.parent || systemId;
+    const isSubId = !isVRSCParent(commitData.parent || undefined, network);
+    const effectiveParent = isSubId ? commitData.parent : systemId;
+    const identityAddress = deriveIdentityAddress(commitData.name, effectiveParent);
+    const identity = createIdentityObject({
+        name: commitData.name,
+        primaryAddresses: params.primaryAddresses,
+        minSigs: params.minSigs,
+        revocationAuthority: params.revocationAuthority || identityAddress,
+        recoveryAuthority: params.recoveryAuthority || identityAddress,
+        parentIAddress,
+        systemId,
+    });
+    const identityScript = buildIdentityScript(identity);
+    const reservationScript = buildReservationScript(identityAddress, Buffer.from(commitData.namereservationHex, 'hex'), isSubId);
+    if (isSubId) {
+        return _buildSubIdRegistration(params, identity, identityScript, reservationScript, identityAddress, parentIAddress, systemId, verusNetwork);
+    }
+    return _buildVrscRegistration(params, identityScript, reservationScript, identityAddress, parentIAddress, systemId, verusNetwork);
+}
+function _buildVrscRegistration(params, identityScript, reservationScript, identityAddress, parentIAddress, systemId, network) {
+    const commitData = params.commitmentData;
+    const hasReferral = !!commitData.referral;
+    const fees = calculateRegistrationFees(hasReferral, params.registrationFee, params.referralLevels);
+    const referralOutputs = [];
+    if (hasReferral) {
+        const chain = (params.referralChain && params.referralChain.length > 0)
+            ? params.referralChain
+            : commitData.referral ? [commitData.referral] : [];
+        for (const referrerAddr of chain) {
+            referralOutputs.push({
+                script: buildReferralPaymentScript(referrerAddr),
+                value: fees.referralAmount,
+            });
+        }
+    }
+    // requiredNative = full registration fee (referral outputs come out of this total)
+    // implicit fee to miners = totalFee - sum(referral outputs) + txFee
+    const totalFee = params.registrationFee ?? index_js_1.DEFAULT_REGISTRATION_FEE;
+    const totalReferralPayments = referralOutputs.reduce((sum, o) => sum + o.value, 0);
+    const requiredNative = totalFee;
+    const numOutputs = 2 + referralOutputs.length + 1;
+    const selection = (0, index_js_4.selectUtxos)(params.utxos, requiredNative, new Map(), numOutputs, systemId, undefined, true);
+    const txb = new utxo_lib_1.TransactionBuilder(network);
+    txb.setVersion(4);
+    txb.setExpiryHeight(params.expiryHeight || 0);
+    txb.setVersionGroupId(index_js_1.VERSION_GROUP_ID);
+    const commitUtxo = params.commitmentUtxo;
+    txb.addInput(Buffer.from(commitUtxo.txid, 'hex').reverse(), commitUtxo.outputIndex, 0xffffffff, Buffer.from(commitUtxo.script, 'hex'));
+    for (const utxo of selection.selected) {
+        txb.addInput(Buffer.from(utxo.txid, 'hex').reverse(), utxo.outputIndex, 0xffffffff, Buffer.from(utxo.script, 'hex'));
+    }
+    txb.addOutput(identityScript, 0);
+    for (const referralOut of referralOutputs) {
+        txb.addOutput(referralOut.script, referralOut.value);
+    }
+    txb.addOutput(reservationScript, 0);
+    if (selection.nativeChange > 0) {
+        txb.addOutput(params.changeAddress, selection.nativeChange);
+    }
+    const unsignedTx = txb.buildIncomplete();
+    const allUtxos = [commitUtxo, ...selection.selected];
+    // The registration fee is burned as an IMPLICIT miner fee (identity and
+    // reservation outputs carry 0; referral payouts come out of the total) —
+    // this matches on-chain registrations, and the daemon exempts recognized
+    // identity definitions from its absurd-fee check (IS_HIGH_FEE). utxo-lib's
+    // client-side fee-rate cap (default 2500 sat/vbyte) must be told the
+    // intended absolute fee or build() throws "Transaction has absurd fees".
+    const expectedImplicitFee = commitUtxo.satoshis + totalFee - totalReferralPayments + selection.fee;
+    const { signedTx, txid } = (0, index_js_3.signTransactionSmart)(unsignedTx.toHex(), params.wif, allUtxos, network, expectedImplicitFee);
+    return {
+        signedTx,
+        txid,
+        fee: selection.fee,
+        identityAddress,
+        registrationFee: totalFee - totalReferralPayments,
+        referralPayments: referralOutputs.length,
+        referralAmountEach: fees.referralAmount,
+        inputsUsed: allUtxos.length,
+        nativeChange: selection.nativeChange,
+    };
+}
+function _buildSubIdRegistration(params, identity, identityScript, reservationScript, identityAddress, parentIAddress, systemId, network) {
+    const registrationFeeAmount = params.registrationFeeAmount;
+    if (!registrationFeeAmount || registrationFeeAmount <= 0) {
+        throw new Error('registrationFeeAmount is required for sub-ID registration. ' +
+            'Specify the fee in parent currency satoshis.');
+    }
+    const feeOutput = buildRegistrationFeeOutput(parentIAddress, registrationFeeAmount, systemId, params.changeAddress);
+    const requiredCurrencies = new Map([
+        [parentIAddress, registrationFeeAmount],
+    ]);
+    const nativeImportFee = params.nativeImportFee || 0;
+    const nativeTarget = feeOutput.nativeValue + nativeImportFee;
+    const numOutputs = 4;
+    const selection = (0, index_js_4.selectUtxos)(params.utxos, nativeTarget, requiredCurrencies, numOutputs, systemId, undefined, true);
+    const txb = new utxo_lib_1.TransactionBuilder(network);
+    txb.setVersion(4);
+    txb.setExpiryHeight(params.expiryHeight || 0);
+    txb.setVersionGroupId(index_js_1.VERSION_GROUP_ID);
+    const commitUtxo = params.commitmentUtxo;
+    txb.addInput(Buffer.from(commitUtxo.txid, 'hex').reverse(), commitUtxo.outputIndex, 0xffffffff, Buffer.from(commitUtxo.script, 'hex'));
+    for (const utxo of selection.selected) {
+        txb.addInput(Buffer.from(utxo.txid, 'hex').reverse(), utxo.outputIndex, 0xffffffff, Buffer.from(utxo.script, 'hex'));
+    }
+    txb.addOutput(identityScript, 0);
+    txb.addOutput(feeOutput.script, feeOutput.nativeValue);
+    txb.addOutput(reservationScript, 0);
+    const hasTokenChange = selection.currencyChanges.size > 0;
+    if (hasTokenChange || selection.nativeChange > 0) {
+        if (hasTokenChange) {
+            const tokenChangeScript = buildTokenChangeOutput(params.changeAddress, selection.currencyChanges);
+            txb.addOutput(tokenChangeScript.script, selection.nativeChange);
+        }
+        else {
+            txb.addOutput(params.changeAddress, selection.nativeChange);
+        }
+    }
+    const unsignedTx = txb.buildIncomplete();
+    const allUtxos = [commitUtxo, ...selection.selected];
+    const { signedTx, txid } = (0, index_js_3.signTransactionSmart)(unsignedTx.toHex(), params.wif, allUtxos, network);
+    return {
+        signedTx,
+        txid,
+        fee: selection.fee,
+        identityAddress,
+        registrationFee: registrationFeeAmount,
+        referralPayments: 0,
+        referralAmountEach: 0,
+        inputsUsed: allUtxos.length,
+        nativeChange: selection.nativeChange,
+    };
+}
+/**
+ * Build and sign an identity update transaction
+ */
+function buildAndSignIdentityUpdate(params, network, operation = 'update', lockUnlockParams) {
+    validateIdentityWif(params.wif);
+    if (!params.identityHex) {
+        throw new errors_js_1.TransactionBuildError('identityHex is required');
+    }
+    if (!params.utxos || params.utxos.length === 0) {
+        throw new errors_js_1.TransactionBuildError('At least one funding UTXO is required');
+    }
+    const verusNetwork = (0, index_js_3.getNetwork)(network === 'testnet');
+    const networkConfig = index_js_1.NETWORK_CONFIG[network];
+    const systemId = networkConfig.chainId;
+    const identity = new verus_typescript_primitives_1.Identity();
+    identity.fromBuffer(Buffer.from(params.identityHex, 'hex'));
+    switch (operation) {
+        case 'update': {
+            if (params.primaryAddresses) {
+                identity.setPrimaryAddresses(params.primaryAddresses);
+            }
+            if (params.minSigs !== undefined) {
+                identity.min_sigs = new bn_js_1.default(params.minSigs);
+            }
+            if (params.revocationAuthority) {
+                identity.setRevocation(params.revocationAuthority);
+            }
+            if (params.recoveryAuthority) {
+                identity.setRecovery(params.recoveryAuthority);
+            }
+            if (params.contentMap) {
+                for (const [key, value] of Object.entries(params.contentMap)) {
+                    identity.content_map.set(key, Buffer.from(value, 'hex'));
+                }
+            }
+            if (params.contentMultimap) {
+                const jsonObj = {};
+                for (const [key, value] of Object.entries(params.contentMultimap)) {
+                    jsonObj[key] = Array.isArray(value) ? value : [value];
+                }
+                identity.content_multimap = verus_typescript_primitives_1.ContentMultiMap.fromJson(jsonObj);
+            }
+            break;
+        }
+        case 'revoke': {
+            identity.clearContentMultiMap();
+            identity.revoke();
+            break;
+        }
+        case 'recover': {
+            identity.unrevoke();
+            identity.clearContentMultiMap();
+            if (params.primaryAddresses) {
+                identity.setPrimaryAddresses(params.primaryAddresses);
+            }
+            if (params.revocationAuthority) {
+                identity.setRevocation(params.revocationAuthority);
+            }
+            if (params.recoveryAuthority) {
+                identity.setRecovery(params.recoveryAuthority);
+            }
+            break;
+        }
+        case 'lock': {
+            const unlockAfter = lockUnlockParams?.unlockAfter;
+            if (!unlockAfter) {
+                throw new Error('unlockAfter (block height) is required for lock operation');
+            }
+            identity.lock(new bn_js_1.default(unlockAfter));
+            break;
+        }
+        case 'unlock': {
+            identity.unlock(new bn_js_1.default(0), new bn_js_1.default(params.expiryHeight || 0));
+            break;
+        }
+    }
+    const identityBuf = identity.toBuffer();
+    const unfundedHex = createUnfundedIdentityUpdate(identityBuf.toString('hex'), verusNetwork, params.expiryHeight || 0);
+    const selection = (0, index_js_4.selectUtxos)(params.utxos, 0, new Map(), 1, systemId, undefined, true);
+    const txb = new utxo_lib_1.TransactionBuilder(verusNetwork);
+    txb.setVersion(4);
+    txb.setExpiryHeight(params.expiryHeight || 0);
+    txb.setVersionGroupId(index_js_1.VERSION_GROUP_ID);
+    for (const utxo of selection.selected) {
+        txb.addInput(Buffer.from(utxo.txid, 'hex').reverse(), utxo.outputIndex, 0xffffffff, Buffer.from(utxo.script, 'hex'));
+    }
+    const unfundedTx = utxo_lib_1.Transaction.fromHex(unfundedHex, verusNetwork);
+    for (const out of unfundedTx.outs) {
+        txb.addOutput(out.script, out.value);
+    }
+    if (selection.nativeChange > 0) {
+        txb.addOutput(params.changeAddress, selection.nativeChange);
+    }
+    const fundedTx = txb.buildIncomplete();
+    const fundedHex = fundedTx.toHex();
+    const prevOutScripts = selection.selected.map(u => Buffer.from(u.script, 'hex'));
+    const idUtxo = params.identityUtxo;
+    const completedHex = completeFundedIdentityUpdate(fundedHex, verusNetwork, prevOutScripts, {
+        hash: Buffer.from(idUtxo.txid, 'hex').reverse(),
+        index: idUtxo.outputIndex,
+        sequence: 0xffffffff,
+        script: Buffer.from(idUtxo.script, 'hex'),
+    });
+    const allUtxos = [...selection.selected, idUtxo];
+    const { signedTx, txid } = (0, index_js_3.signTransactionSmart)(completedHex, params.wif, allUtxos, verusNetwork);
+    return {
+        signedTx,
+        txid,
+        fee: selection.fee,
+        identityAddress: identity.getIdentityAddress(),
+        operation,
+        inputsUsed: allUtxos.length,
+        nativeChange: selection.nativeChange,
+    };
+}
+//# sourceMappingURL=index.js.map