@chainvue/verus-sdk 0.7.0 → 0.9.0

package/dist/identity/index.js

@@ -47,6 +47,7 @@ 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 brands_js_1 = require("../core/brands.js");
 const errors_js_1 = require("../errors.js");
 const index_js_5 = require("../keys/index.js");
 const { createUnfundedIdentityUpdate, completeFundedIdentityUpdate } = utxo_lib_1.smarttxs;
@@ -56,6 +57,10 @@ const HASH256_BYTE_LENGTH = 32;
 const NULL_ID_HASH = Buffer.alloc(HASH160_BYTE_LENGTH, 0);
 /** Eval code for CAdvancedNameReservation (sub-ID) */
 const EVAL_IDENTITY_ADVANCEDRESERVATION = 10;
+/** Consensus maximum identity unlock delay (blocks) — CIdentity::MAX_UNLOCK_DELAY, ~22 years. */
+const MAX_UNLOCK_DELAY = 11563200;
+/** ~1 year of blocks (1 block/min); a lock delay above this needs an explicit opt-in. */
+const LOCK_DELAY_SANITY_BLOCKS = 525600;
 // ─── Script / Hash Builders ────────────────────────────────────────
 /**
  * Assert a base58check address has the expected version byte.
@@ -214,6 +219,14 @@ function buildIdentityScript(identity) {
  * Derive the identity i-address from a name and optional parent
  */
 function deriveIdentityAddress(name, parentIAddress) {
+    // nameAndParentAddrToIAddr hashes fromBase58Check(parent).hash regardless of
+    // version, so an R-address parent is laundered into an identity-versioned hash
+    // that names no real currency. The derived i-address then looks valid but can
+    // never be registered — funds paid to it (pay-to-unregistered-identity) burn,
+    // and a name commitment built with it wastes its fee. Require an i-address.
+    if (parentIAddress) {
+        assertAddressVersion(parentIAddress, index_js_1.I_ADDR_VERSION, 'parent');
+    }
     return (0, verus_typescript_primitives_3.nameAndParentAddrToIAddr)(name, parentIAddress || undefined);
 }
 /**
@@ -228,14 +241,29 @@ function isVRSCParent(parentIAddress, network = 'mainnet') {
 /**
  * Build the full commitment data needed for Step 1 of identity creation
  */
-function prepareNameCommitment(name, controlAddress, referralIAddress, parentIAddress, network = 'mainnet') {
-    const salt = generateSalt();
+function prepareNameCommitment(name, controlAddress, referralIAddress, parentIAddress, network = 'mainnet', 
+/**
+ * Explicit 32-byte salt. Omit for a fresh random salt (the normal path); pass
+ * a fixed value only to make the commitment deterministic for golden/diff
+ * tests. A reused salt on a real registration is a privacy leak, so callers
+ * outside tests must not set it.
+ */
+salt = generateSalt()) {
     const systemId = index_js_1.NETWORK_CONFIG[network].chainId;
     // iAddressToHash discards the version byte, so an R-address referral would be
     // laundered into a hash that names no identity (the daemon rejects the
     // registration and the commitment fee is wasted). Require an i-address.
     if (referralIAddress) {
         assertAddressVersion(referralIAddress, index_js_1.I_ADDR_VERSION, 'referral');
+        // A sub-ID commitment (non-VRSC parent) would bake the referral into the
+        // advanced reservation hash, but _buildSubIdRegistration emits NO referral
+        // payout — the registration would then mismatch its own committed hash and
+        // the daemon rejects it, wasting the commitment fee. Fail closed here rather
+        // than committing a referral this SDK cannot honor.
+        if (!isVRSCParent(parentIAddress, network)) {
+            throw new errors_js_1.TransactionBuildError('referrals are not supported for sub-ID (non-VRSC-parent) registrations in this SDK; ' +
+                'omit the referral for a sub-ID name commitment.');
+        }
     }
     const referralHash = referralIAddress
         ? (0, index_js_2.iAddressToHash)(referralIAddress)
@@ -256,7 +284,7 @@ function prepareNameCommitment(name, controlAddress, referralIAddress, parentIAd
     }
     const commitmentHash = calculateCommitmentHash(serializedReservation);
     const serializedCommitmentHash = serializeCommitmentHash(commitmentHash);
-    const commitmentScript = buildCommitmentScript(commitmentHash, controlAddress);
+    const commitmentScript = buildCommitmentScript(commitmentHash, (0, brands_js_1.parseRAddress)(controlAddress, 'controlAddress'));
     return {
         salt,
         serializedReservation,
@@ -267,18 +295,17 @@ function prepareNameCommitment(name, controlAddress, referralIAddress, parentIAd
     };
 }
 /**
- * Build a P2ID output script (pay to identity)
+ * Build a pay-to-identity output script for an i-address.
+ *
+ * Alias of {@link identityPaymentScript}. This previously emitted the bare
+ * 26-byte template `OP_DUP OP_HASH160 <idhash> OP_EQUALVERIFY OP_CHECKSIG
+ * OP_CHECKCRYPTOCONDITION`, which is NOT a valid Verus scriptPubKey — a Verus
+ * P2ID is a CryptoCondition (OptCCParams) output. Funds sent to the old
+ * template would have gone to a non-standard script the daemon does not treat
+ * as identity-spendable. It now delegates to the chain-verified CC builder.
  */
 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,
-    ]);
+    return identityPaymentScript((0, brands_js_1.parseIAddress)(iAddress, 'iAddress'));
 }
 /**
  * The standard pay-to-identity output script (CC EVAL_NONE 1-of-1 to an
@@ -290,7 +317,9 @@ function identityPaymentScript(iAddress) {
     return buildReferralPaymentScript(iAddress);
 }
 /**
- * Build a CC referral payment output script
+ * Build a CC referral payment output script. Requires an already-parsed
+ * i-address: IdentityID.fromAddress launders the version byte, so accepting a
+ * raw string here is exactly the hole that let a wrong-kind address through.
  */
 function buildReferralPaymentScript(iAddress) {
     const identityDest = new verus_typescript_primitives_1.TxDestination(verus_typescript_primitives_1.IdentityID.fromAddress(iAddress));
@@ -331,9 +360,9 @@ function calculateRegistrationFees(hasReferral, totalFee = index_js_1.DEFAULT_RE
  * Build a new Identity object for registration
  */
 function createIdentityObject(params) {
-    params.primaryAddresses.forEach((addr, i) => assertAddressVersion(addr, index_js_1.PUBKEY_HASH_PREFIX, `primaryAddresses[${i}]`));
-    assertAddressVersion(params.revocationAuthority, index_js_1.I_ADDR_VERSION, 'revocationAuthority');
-    assertAddressVersion(params.recoveryAuthority, index_js_1.I_ADDR_VERSION, 'recoveryAuthority');
+    // No assertAddressVersion here: the brands guarantee the version bytes. An
+    // R-address primary or an i-address authority is now a compile error at the
+    // call site, where the raw string is parsed.
     validateMinSigs(params.minSigs ?? 1, params.primaryAddresses.length);
     const primaryKeys = params.primaryAddresses.map(addr => verus_typescript_primitives_1.KeyID.fromAddress(addr));
     const identity = new verus_typescript_primitives_1.Identity({
@@ -354,45 +383,79 @@ function createIdentityObject(params) {
 /**
  * Build the parent-currency registration-fee output for a sub-ID.
  *
- * The daemon pays this fee as a plain reserve output (EVAL_RESERVE_OUTPUT)
- * holding `feeAmount` of the parent currency AT the parent currency's own
- * i-address, carrying zero native value. Verified against `registeridentity`
- * on VRSCTEST and an accepted on-chain sub-ID registration: for a currency
- * with idregistrationfees=1.0 the fee output is exactly `{parent: 1.0}` at the
- * parent, 0 native, and the native cost that leaves the transaction is the
- * currency's idimportfees (the caller passes it as `nativeImportFee`).
+ * The fee-output STRUCTURE depends on the parent currency's proofprotocol,
+ * verified against accepted on-chain registrations on VRSCTEST:
+ *  - proofprotocol 2 (centralized / token, e.g. `ownora-nft`): a plain reserve
+ *    output (EVAL_RESERVE_OUTPUT) holding `feeAmount` of the parent AT the
+ *    parent's i-address, ZERO native.
+ *  - otherwise (e.g. proofprotocol 1 PBaaS/fractional, `fum`): a CReserveTransfer
+ *    (EVAL_RESERVE_TRANSFER) of `feeAmount` to the parent, carrying
+ *    RESERVE_TRANSFER_FEE (0.0002) native.
  *
- * A previous implementation built this as a CReserveTransfer to the
- * reserve-transfer eval address carrying 0.0002 native — a cross-currency
- * transfer, not a same-chain fee payment. That structure never matched the
- * daemon and was never accepted at broadcast.
+ * An offline SDK cannot read the parent's proofprotocol, so the caller passes it
+ * (`parentProofProtocol`). In both cases the native the transaction actually
+ * burns is the parent's idimportfees (`nativeImportFee`); the fee output's own
+ * native value is funded and cancels out in the conservation accounting.
  *
- * `systemId`/`_controlAddress` are retained for signature compatibility and
- * are unused: the fee is denominated in and paid to the parent currency.
+ * `_controlAddress` is retained for signature compatibility and is unused.
+ */
+function buildRegistrationFeeOutput(parentCurrencyId, feeAmount, systemId, _controlAddress, parentProofProtocol = 2) {
+    if (parentProofProtocol === 2) {
+        return buildTokenChangeOutput((0, brands_js_1.parseIAddress)(parentCurrencyId, 'parentCurrencyId'), new Map([[parentCurrencyId, feeAmount]]));
+    }
+    return buildRegistrationFeeReserveTransfer(parentCurrencyId, feeAmount, systemId);
+}
+/**
+ * CReserveTransfer fee output for a sub-ID under a non-centralized (proofprotocol
+ * != 2) parent — the daemon's form for PBaaS/fractional currencies. Carries
+ * RESERVE_TRANSFER_FEE native.
  */
-function buildRegistrationFeeOutput(parentCurrencyId, feeAmount, systemId, _controlAddress) {
-    void systemId;
-    return buildTokenChangeOutput(parentCurrencyId, new Map([[parentCurrencyId, feeAmount]]));
+function buildRegistrationFeeReserveTransfer(parentCurrencyId, feeAmount, systemId) {
+    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.toString(10))]]),
+        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.toString(10)),
+        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) {
-    // KeyID.fromAddress launders any address to the R-address form, so token
-    // change to an i-address changeAddress was paid to a transparent script
-    // nobody controls (burned on paths with no funded-transfer validator). Build
-    // a pay-to-identity destination for i-addresses, and reject anything that is
-    // neither an R- nor an i-address rather than silently mis-routing it.
-    const version = (0, verus_typescript_primitives_3.fromBase58Check)(changeAddress).version;
+    // The brand guarantees the version; narrow it to pick the destination form.
+    // A pay-to-identity destination for i-addresses (KeyID.fromAddress would
+    // launder an i-address to a transparent script nobody controls), a KeyID for
+    // R-addresses, and reject a P2SH address (not a valid reserve destination).
     let destination;
-    if (version === index_js_1.I_ADDR_VERSION) {
+    if ((0, brands_js_1.isIAddress)(changeAddress)) {
         destination = new verus_typescript_primitives_1.TxDestination(verus_typescript_primitives_1.IdentityID.fromAddress(changeAddress));
     }
-    else if (version === index_js_1.PUBKEY_HASH_PREFIX) {
+    else if ((0, brands_js_1.isRAddress)(changeAddress)) {
         destination = new verus_typescript_primitives_1.TxDestination(verus_typescript_primitives_1.KeyID.fromAddress(changeAddress));
     }
     else {
-        throw new errors_js_1.TransactionBuildError(`token change address must be an R-address or identity i-address, got version ${version}: ${changeAddress}`);
+        throw new errors_js_1.TransactionBuildError(`token change address must be an R-address or identity i-address, got: ${changeAddress}`);
     }
     const valueMap = new Map();
     for (const [currency, amount] of currencyChanges) {
@@ -462,7 +525,7 @@ function buildAndSignCommitment(params, network) {
     // (KeyID.fromAddress laundered it to an uncontrollable key — permanently
     // unspendable, wasting the commitment fee). Derive it from the WIF instead.
     const controlAddress = utxo_lib_1.ECPair.fromWIF(params.wif, verusNetwork).getAddress();
-    const commitment = prepareNameCommitment(params.name, controlAddress, params.referral, params.parent, network);
+    const commitment = prepareNameCommitment(params.name, controlAddress, params.referral, params.parent, network, params.salt);
     const utxos = params.utxos;
     const selection = (0, index_js_4.selectUtxos)(utxos, 0n, new Map(), 1, networkConfig.chainId, undefined, true);
     const txb = new utxo_lib_1.TransactionBuilder(verusNetwork);
@@ -473,18 +536,35 @@ function buildAndSignCommitment(params, network) {
         txb.addInput(Buffer.from(utxo.txid, 'hex').reverse(), utxo.outputIndex, 0xffffffff, Buffer.from(utxo.script, 'hex'));
     }
     txb.addOutput(commitment.commitmentScript, 0);
-    if (selection.nativeChange > 0n) {
-        // utxo-lib's addOutput only resolves base58 R-addresses; an i-address
-        // changeAddress needs the explicit P2ID script (matching sendCurrency), or
-        // it throws an untyped "no matching Script".
-        if (params.changeAddress.startsWith('i')) {
-            txb.addOutput(identityPaymentScript(params.changeAddress), (0, index_js_2.toSafeNumber)(selection.nativeChange));
+    // If native-only UTXOs can't cover the fee, selectUtxos falls back to a
+    // token-bearing UTXO and returns its token value as currencyChanges. Emit it
+    // as a reserve-output change (bundled with the native change) — otherwise
+    // that token value is silently forfeited to the miner.
+    const hasTokenChange = selection.currencyChanges.size > 0;
+    if (hasTokenChange || selection.nativeChange > 0n) {
+        if (hasTokenChange) {
+            const tokenChangeScript = buildTokenChangeOutput((0, brands_js_1.parseAddress)(params.changeAddress, 'changeAddress'), selection.currencyChanges);
+            txb.addOutput(tokenChangeScript.script, (0, index_js_2.toSafeNumber)(selection.nativeChange));
+        }
+        else if (params.changeAddress.startsWith('i')) {
+            // utxo-lib's addOutput only resolves base58 R-addresses; an i-address
+            // changeAddress needs the explicit P2ID script (matching sendCurrency), or
+            // it throws an untyped "no matching Script".
+            txb.addOutput(identityPaymentScript((0, brands_js_1.parseIAddress)(params.changeAddress, 'changeAddress')), (0, index_js_2.toSafeNumber)(selection.nativeChange));
         }
         else {
             txb.addOutput(params.changeAddress, (0, index_js_2.toSafeNumber)(selection.nativeChange));
         }
     }
+    // No token is paid out here (the commitment output carries none), so every
+    // token in the selected inputs must return as change.
+    (0, index_js_4.assertTokenConservation)(selection.selected, new Map(), selection.currencyChanges, networkConfig.chainId, 'name commitment');
     const unsignedTx = txb.buildIncomplete();
+    // Native value conservation: the commitment output is 0 and change is native,
+    // so the assembled native fee must equal selection.fee. The fork's absurd-fee
+    // guard is blind for inputs > 2^32 sats (it truncates input value mod 2^32),
+    // so this bigint check is the real backstop against a change-accounting slip.
+    (0, index_js_3.assertNativeConservation)(selection.selected, unsignedTx.outs, selection.fee, 'name commitment');
     const { signedTx, txid } = (0, index_js_3.signTransactionSmart)(unsignedTx.toHex(), params.wif, selection.selected, verusNetwork);
     return {
         signedTx,
@@ -515,6 +595,17 @@ function buildAndSignRegistration(params, network) {
     const verusNetwork = (0, index_js_3.getNetwork)(network === 'testnet');
     const networkConfig = index_js_1.NETWORK_CONFIG[network];
     const systemId = networkConfig.chainId;
+    // Step 2 spends the name-commitment output, which is controlled by the key that
+    // created it in step 1. The fork signs the commitment input with whatever WIF it
+    // is handed, so a mismatched WIF produces a tx the daemon rejects at broadcast
+    // (and the commitment fee is wasted). Verify the WIF's hash is the commitment's
+    // control hash up front. (The 20-byte control hash is embedded in the CC script.)
+    const signerAddr = utxo_lib_1.ECPair.fromWIF(params.wif, verusNetwork).getAddress();
+    const signerHash = (0, index_js_2.addressToScriptPubKey)(signerAddr).subarray(3, 23).toString('hex');
+    if (!params.commitmentUtxo.script.toLowerCase().includes(signerHash)) {
+        throw new errors_js_1.TransactionBuildError(`the provided WIF (${signerAddr}) does not control the name-commitment output; step 2 must be ` +
+            `signed by the same key that created the commitment in step 1.`);
+    }
     const commitData = params.commitmentData;
     const parentIAddress = commitData.parent || systemId;
     const isSubId = !isVRSCParent(commitData.parent || undefined, network);
@@ -522,15 +613,15 @@ function buildAndSignRegistration(params, network) {
     const identityAddress = deriveIdentityAddress(commitData.name, effectiveParent);
     const identity = createIdentityObject({
         name: commitData.name,
-        primaryAddresses: params.primaryAddresses,
+        primaryAddresses: params.primaryAddresses.map((a, i) => (0, brands_js_1.parseRAddress)(a, `primaryAddresses[${i}]`)),
         ...(params.minSigs !== undefined ? { minSigs: params.minSigs } : {}),
-        revocationAuthority: params.revocationAuthority || identityAddress,
-        recoveryAuthority: params.recoveryAuthority || identityAddress,
-        parentIAddress,
-        systemId,
+        revocationAuthority: (0, brands_js_1.parseIAddress)(params.revocationAuthority || identityAddress, 'revocationAuthority'),
+        recoveryAuthority: (0, brands_js_1.parseIAddress)(params.recoveryAuthority || identityAddress, 'recoveryAuthority'),
+        parentIAddress: (0, brands_js_1.parseIAddress)(parentIAddress, 'parentIAddress'),
+        systemId: (0, brands_js_1.parseIAddress)(systemId, 'systemId'),
     });
     const identityScript = buildIdentityScript(identity);
-    const reservationScript = buildReservationScript(identityAddress, Buffer.from(commitData.namereservationHex, 'hex'), isSubId);
+    const reservationScript = buildReservationScript((0, brands_js_1.parseIAddress)(identityAddress, 'identityAddress'), Buffer.from(commitData.namereservationHex, 'hex'), isSubId);
     if (isSubId) {
         return _buildSubIdRegistration(params, identity, identityScript, reservationScript, identityAddress, parentIAddress, systemId, verusNetwork);
     }
@@ -557,7 +648,7 @@ function _buildVrscRegistration(params, identityScript, reservationScript, ident
         }
         for (const referrerAddr of chain) {
             referralOutputs.push({
-                script: buildReferralPaymentScript(referrerAddr),
+                script: buildReferralPaymentScript((0, brands_js_1.parseIAddress)(referrerAddr, 'referralChain entry')),
                 value: fees.referralAmount,
             });
         }
@@ -587,17 +678,29 @@ function _buildVrscRegistration(params, identityScript, reservationScript, ident
         txb.addOutput(referralOut.script, (0, index_js_2.toSafeNumber)(referralOut.value));
     }
     txb.addOutput(reservationScript, 0);
-    if (selection.nativeChange > 0n) {
-        // utxo-lib's addOutput only resolves base58 R-addresses; an i-address
-        // changeAddress needs the explicit P2ID script (matching sendCurrency), or
-        // it throws an untyped "no matching Script".
-        if (params.changeAddress.startsWith('i')) {
-            txb.addOutput(identityPaymentScript(params.changeAddress), (0, index_js_2.toSafeNumber)(selection.nativeChange));
+    // Registration needs ~80-100 native, so Phase-2 selection is especially
+    // likely to exhaust pure-native UTXOs and pull a token-bearing one; return
+    // its token value as reserve-output change instead of forfeiting it to the
+    // miner. (The commitment input carries no currency.)
+    const hasTokenChange = selection.currencyChanges.size > 0;
+    if (hasTokenChange || selection.nativeChange > 0n) {
+        if (hasTokenChange) {
+            const tokenChangeScript = buildTokenChangeOutput((0, brands_js_1.parseAddress)(params.changeAddress, 'changeAddress'), selection.currencyChanges);
+            txb.addOutput(tokenChangeScript.script, (0, index_js_2.toSafeNumber)(selection.nativeChange));
+        }
+        else if (params.changeAddress.startsWith('i')) {
+            // utxo-lib's addOutput only resolves base58 R-addresses; an i-address
+            // changeAddress needs the explicit P2ID script (matching sendCurrency), or
+            // it throws an untyped "no matching Script".
+            txb.addOutput(identityPaymentScript((0, brands_js_1.parseIAddress)(params.changeAddress, 'changeAddress')), (0, index_js_2.toSafeNumber)(selection.nativeChange));
         }
         else {
             txb.addOutput(params.changeAddress, (0, index_js_2.toSafeNumber)(selection.nativeChange));
         }
     }
+    // Referral payouts are native; no token is paid out, so all token value in the
+    // selected inputs must return as change.
+    (0, index_js_4.assertTokenConservation)(selection.selected, new Map(), selection.currencyChanges, systemId, 'identity registration');
     const unsignedTx = txb.buildIncomplete();
     const allUtxos = [commitUtxo, ...selection.selected];
     // The registration fee is burned as an IMPLICIT miner fee (identity and
@@ -641,14 +744,38 @@ function _buildSubIdRegistration(params, identity, identityScript, reservationSc
         throw new errors_js_1.TransactionBuildError('registrationFeeAmount is required for sub-ID registration. ' +
             'Specify the fee in parent currency satoshis.');
     }
-    const feeOutput = buildRegistrationFeeOutput(parentIAddress, registrationFeeAmount, systemId, params.changeAddress);
+    // The fee-output structure differs by the parent's proofprotocol (2 =
+    // reserve output, else reserve transfer), which the offline SDK cannot read —
+    // the caller must supply it (from `getcurrency <parent>.proofprotocol`).
+    if (params.parentProofProtocol === undefined) {
+        throw new errors_js_1.TransactionBuildError("parentProofProtocol is required for sub-ID registration: pass the parent currency's proofprotocol " +
+            '(from `getcurrency <parent>`) — 2 for a centralized/token currency, 1 for a PBaaS/fractional one.');
+    }
+    const feeOutput = buildRegistrationFeeOutput(parentIAddress, registrationFeeAmount, systemId, params.changeAddress, params.parentProofProtocol);
     const requiredCurrencies = new Map([
         [parentIAddress, registrationFeeAmount],
     ]);
-    const nativeImportFee = params.nativeImportFee || 0n;
+    // The parent currency's idimportfees must leave the transaction as native fee;
+    // this SDK is offline and cannot read it, so the caller must pass it explicitly.
+    // Silently defaulting to 0 underfunds a currency that charges an import fee, and
+    // the daemon rejects the registration.
+    if (params.nativeImportFee === undefined) {
+        throw new errors_js_1.TransactionBuildError("nativeImportFee is required for sub-ID registration: pass the parent currency's idimportfees " +
+            '(from `getcurrency <parent>`), or 0n if it charges none.');
+    }
+    const nativeImportFee = params.nativeImportFee;
     const nativeTarget = feeOutput.nativeValue + nativeImportFee;
     const numOutputs = 4;
-    const selection = (0, index_js_4.selectUtxos)(params.utxos, nativeTarget, requiredCurrencies, numOutputs, systemId, undefined, true);
+    const selection = (0, index_js_4.selectUtxos)(params.utxos, nativeTarget, requiredCurrencies, numOutputs, systemId, undefined, true, 
+    // The identity and reservation outputs embed the full serialized identity /
+    // advanced name reservation (a large contentMultimap can make them
+    // multi-KB); size the fee from their real bytes, matching the VRSC
+    // registration / update / define paths, so a big sub-ID isn't fee-estimated
+    // below the relay minimum and rejected.
+    identityScript.length + reservationScript.length + feeOutput.script.length);
+    // The parent-currency fee (requiredCurrencies) is paid to the fee output and
+    // any excess returns as token change; guard that no token value is dropped.
+    (0, index_js_4.assertTokenConservation)(selection.selected, requiredCurrencies, selection.currencyChanges, systemId, 'sub-ID registration');
     const txb = new utxo_lib_1.TransactionBuilder(network);
     txb.setVersion(4);
     txb.setExpiryHeight((0, index_js_3.resolveExpiryHeight)(params.expiryHeight));
@@ -664,7 +791,7 @@ function _buildSubIdRegistration(params, identity, identityScript, reservationSc
     const hasTokenChange = selection.currencyChanges.size > 0;
     if (hasTokenChange || selection.nativeChange > 0n) {
         if (hasTokenChange) {
-            const tokenChangeScript = buildTokenChangeOutput(params.changeAddress, selection.currencyChanges);
+            const tokenChangeScript = buildTokenChangeOutput((0, brands_js_1.parseAddress)(params.changeAddress, 'changeAddress'), selection.currencyChanges);
             txb.addOutput(tokenChangeScript.script, (0, index_js_2.toSafeNumber)(selection.nativeChange));
         }
         else {
@@ -672,7 +799,7 @@ function _buildSubIdRegistration(params, identity, identityScript, reservationSc
             // changeAddress needs the explicit P2ID script (matching sendCurrency), or
             // it throws an untyped "no matching Script".
             if (params.changeAddress.startsWith('i')) {
-                txb.addOutput(identityPaymentScript(params.changeAddress), (0, index_js_2.toSafeNumber)(selection.nativeChange));
+                txb.addOutput(identityPaymentScript((0, brands_js_1.parseIAddress)(params.changeAddress, 'changeAddress')), (0, index_js_2.toSafeNumber)(selection.nativeChange));
             }
             else {
                 txb.addOutput(params.changeAddress, (0, index_js_2.toSafeNumber)(selection.nativeChange));
@@ -742,6 +869,17 @@ function buildAndSignIdentityUpdate(params, network, operation = 'update', lockU
             throw new errors_js_1.TransactionBuildError(`the provided WIF (${signerAddress}) is not among the identity's primary addresses ` +
                 `[${currentPrimaries.join(', ')}]; it cannot authorize a ${operation}.`);
         }
+        // Spending the identity input under primary authority needs min_sigs
+        // signatures, but this SDK signs with a single WIF and the bundled fork
+        // cannot attach a second signature to a CryptoCondition input. Emitting a
+        // 1-of-N-signed tx for a min_sigs>1 identity yields a hex the daemon rejects
+        // at broadcast; fail closed instead.
+        const currentMinSigs = identity.min_sigs?.toNumber?.() ?? 1;
+        if (currentMinSigs > 1) {
+            throw new errors_js_1.TransactionBuildError(`this identity requires ${currentMinSigs} signatures (min_sigs > 1); the SDK signs with a single ` +
+                `WIF and the bundled fork cannot multi-sign a CryptoCondition input, so a valid ${operation} ` +
+                `transaction cannot be produced. Use the daemon for multisig identities.`);
+        }
     }
     switch (operation) {
         case 'update': {
@@ -760,13 +898,21 @@ function buildAndSignIdentityUpdate(params, network, operation = 'update', lockU
                 identity.setRecovery(params.recoveryAuthority);
             }
             if (params.contentMap) {
+                // The daemon REPLACES the whole contentmap when the field is provided
+                // (and the contentMultimap branch below already replaces via fromJson).
+                // Merging into the parsed on-chain map instead re-attested stale keys and
+                // gave no way to delete one. Clear first so the provided map is authoritative.
+                identity.content_map.clear();
                 for (const [key, value] of Object.entries(params.contentMap)) {
-                    // Buffer.from(_, 'hex') silently drops non-hex characters and
-                    // truncates odd-length input, so a malformed value would be committed
-                    // to the identity on-chain as wrong/empty bytes with no error. Reject
-                    // it instead.
-                    if (!/^[0-9a-fA-F]*$/.test(value) || value.length % 2 !== 0) {
-                        throw new errors_js_1.TransactionBuildError(`contentMap["${key}"] must be an even-length hex string (got ${JSON.stringify(value)})`);
+                    // Keys are vdxf i-addresses; the primitives run fromBase58Check(key),
+                    // which discards the version byte — guard it like the multimap branch.
+                    assertAddressVersion(key, index_js_1.I_ADDR_VERSION, `contentMap key "${key}"`);
+                    // Values serialize as a fixed uint256 (32 bytes). Buffer.from(_, 'hex')
+                    // silently drops non-hex and truncates, so a wrong-length value would be
+                    // committed on-chain as wrong bytes (or build a payload the daemon can't
+                    // deserialize). Require exactly 64 hex chars.
+                    if (!/^[0-9a-fA-F]{64}$/.test(value)) {
+                        throw new errors_js_1.TransactionBuildError(`contentMap["${key}"] must be a 32-byte (64-hex-char) value (got ${JSON.stringify(value)})`);
                     }
                     identity.content_map.set(key, Buffer.from(value, 'hex'));
                 }
@@ -804,6 +950,13 @@ function buildAndSignIdentityUpdate(params, network, operation = 'update', lockU
             if (params.primaryAddresses) {
                 identity.setPrimaryAddresses(params.primaryAddresses);
             }
+            // Recovery commonly replaces the primary set; allow lowering min_sigs so a
+            // 2-of-2 identity can be recovered to a single fresh key (otherwise the
+            // stale min_sigs would exceed the new primary count — see the guard below).
+            if (params.minSigs !== undefined) {
+                validateMinSigs(params.minSigs, identity.primary_addresses?.length ?? 0);
+                identity.min_sigs = new bn_js_1.default(params.minSigs);
+            }
             if (params.revocationAuthority) {
                 identity.setRevocation(params.revocationAuthority);
             }
@@ -813,11 +966,20 @@ function buildAndSignIdentityUpdate(params, network, operation = 'update', lockU
             break;
         }
         case 'lock': {
-            const unlockAfter = lockUnlockParams?.unlockAfter;
-            if (!unlockAfter) {
-                throw new errors_js_1.TransactionBuildError('unlockAfter (block height) is required for lock operation');
+            const delay = lockUnlockParams?.unlockDelayBlocks;
+            if (delay === undefined || !Number.isInteger(delay) || delay <= 0) {
+                throw new errors_js_1.TransactionBuildError('unlockDelayBlocks (a positive integer RELATIVE delay in blocks, not a block height) is required for lock');
             }
-            identity.lock(new bn_js_1.default(unlockAfter));
+            if (delay > MAX_UNLOCK_DELAY) {
+                throw new errors_js_1.TransactionBuildError(`unlockDelayBlocks ${delay} exceeds the consensus maximum ${MAX_UNLOCK_DELAY} (~22 years)`);
+            }
+            // A block height (millions) passed as a delay locks the identity for years.
+            // Require an explicit opt-in above ~1 year to catch that mistake.
+            if (delay > LOCK_DELAY_SANITY_BLOCKS && !lockUnlockParams?.sanityOverride) {
+                throw new errors_js_1.TransactionBuildError(`unlockDelayBlocks ${delay} is over ~1 year (${LOCK_DELAY_SANITY_BLOCKS} blocks) — this is a RELATIVE ` +
+                    `delay, not a block height; pass sanityOverride: true if that long a lock is intended.`);
+            }
+            identity.lock(new bn_js_1.default(delay));
             break;
         }
         case 'unlock': {
@@ -834,6 +996,15 @@ function buildAndSignIdentityUpdate(params, network, operation = 'update', lockU
             break;
         }
     }
+    // A valid identity always has min_sigs <= number of primary addresses. Shrinking
+    // the primary set (update/recover) without lowering minSigs would leave a stale
+    // min_sigs the daemon rejects — or, worse, a permanently unspendable identity.
+    const finalPrimaries = identity.primary_addresses?.length ?? 0;
+    const finalMinSigs = identity.min_sigs?.toNumber?.() ?? 1;
+    if (finalMinSigs > finalPrimaries) {
+        throw new errors_js_1.TransactionBuildError(`resulting identity has min_sigs ${finalMinSigs} but only ${finalPrimaries} primary address(es); ` +
+            `pass minSigs to lower it when reducing the primary set.`);
+    }
     const identityBuf = identity.toBuffer();
     const unfundedHex = createUnfundedIdentityUpdate(identityBuf.toString('hex'), verusNetwork, (0, index_js_3.resolveExpiryHeight)(params.expiryHeight));
     const selection = (0, index_js_4.selectUtxos)(params.utxos, 0n, new Map(), 1, systemId, undefined, true, 
@@ -841,6 +1012,10 @@ function buildAndSignIdentityUpdate(params, network, operation = 'update', lockU
     // contentMultimap can make it multi-KB); size the fee from its real bytes
     // so a big update isn't fee-estimated below the relay minimum.
     unfundedHex.length / 2);
+    // Update spends only native fees and emits no token-change output, so a
+    // token-bearing funding UTXO would be silently dropped. Fail closed if one
+    // was selected (both maps empty ⇒ assert no token enters).
+    (0, index_js_4.assertTokenConservation)(selection.selected, new Map(), new Map(), systemId, 'identity update');
     const txb = new utxo_lib_1.TransactionBuilder(verusNetwork);
     txb.setVersion(4);
     txb.setExpiryHeight((0, index_js_3.resolveExpiryHeight)(params.expiryHeight));
@@ -857,7 +1032,7 @@ function buildAndSignIdentityUpdate(params, network, operation = 'update', lockU
         // changeAddress needs the explicit P2ID script (matching sendCurrency), or
         // it throws an untyped "no matching Script".
         if (params.changeAddress.startsWith('i')) {
-            txb.addOutput(identityPaymentScript(params.changeAddress), (0, index_js_2.toSafeNumber)(selection.nativeChange));
+            txb.addOutput(identityPaymentScript((0, brands_js_1.parseIAddress)(params.changeAddress, 'changeAddress')), (0, index_js_2.toSafeNumber)(selection.nativeChange));
         }
         else {
             txb.addOutput(params.changeAddress, (0, index_js_2.toSafeNumber)(selection.nativeChange));