@bitgo/abstract-eth 25.2.0 → 25.3.1

package/dist/src/lib/zamaUtils.d.ts

@@ -2,6 +2,11 @@ export declare const delegateForUserDecryptionTypes: readonly ["address", "addre
 export declare const callFromParentTypes: readonly ["address", "uint256", "bytes"];
 export declare const aclMulticallTypes: readonly ["bytes[]"];
 export declare const approveTypes: readonly ["address", "uint256"];
+export declare const wrapTypes: readonly ["address", "uint256"];
+export declare const unwrapTypes: readonly ["address", "address", "bytes32", "bytes"];
+export declare const finalizeUnwrapTypes: readonly ["bytes32", "uint64", "bytes"];
+/** Max value for Solidity `uint64` / ERC-7984 confidential amount domain (`euint64`). */
+export declare const UINT64_MAX = 18446744073709551615n;
 /**
  * Function selector for ACL.delegateForUserDecryption(address,address,uint64)
  * = keccak256('delegateForUserDecryption(address,address,uint64)')[0:4]
@@ -24,6 +29,30 @@ export declare const callFromParentMethodId: string;
  * Used for exact-amount (and approve(0) reset) approvals of the ERC-7984 wrapper as spender.
  */
 export declare const approveMethodId: string;
+/**
+ * Function selector for ERC-7984 wrap(address,uint256)
+ * = keccak256('wrap(address,uint256)')[0:4]
+ * Locks underlying ERC-20 in the wrapper and mints an encrypted balance to `to`.
+ */
+export declare const wrapMethodId: string;
+/**
+ * Function selector for ERC-7984 unwrap(address,address,bytes32,bytes)
+ * = keccak256('unwrap(address,address,bytes32,bytes)')[0:4]
+ * Burns confidential balance and requests release of underlying ERC-20 escrow.
+ */
+export declare const unwrapMethodId: string;
+/**
+ * Function selector for ERC-7984 finalizeUnwrap(bytes32,uint64,bytes)
+ * = keccak256('finalizeUnwrap(bytes32,uint64,bytes)')[0:4]
+ * Completes unshield after oracle decryption of the phase-1 unwrap request.
+ */
+export declare const finalizeUnwrapMethodId: string;
+/**
+ * Asserts that `amount * rate` fits in uint64 (ERC-7984 confidential mint domain).
+ *
+ * @throws {Error} if amount or rate is invalid, or the product exceeds uint64
+ */
+export declare function assertAmountTimesRateFitsUint64(amount: string | number | bigint, rate: string | number | bigint): void;
 /**
  * Encodes ERC-20 `approve(spender, amount)` calldata for ERC-7984 shield.
  *
@@ -40,6 +69,88 @@ export declare const approveMethodId: string;
  * @throws {Error} if the wrapper address is invalid or amount is negative
  */
 export declare function buildApproveCalldata(wrapperAddress: string, amount: string | number | bigint): string;
+/**
+ * Encodes ERC-7984 `wrap(to, amount)` calldata for the shield path.
+ *
+ * Calldata is sent to the confidential wrapper contract. `to` is the recipient of
+ * the minted encrypted balance (self-directed shields use the wallet base address).
+ * When `rate` is provided, validates that `amount × rate` fits uint64 (`euint64`).
+ * `rate` is not encoded in calldata (deserialize round-trips omit it).
+ *
+ * Does not set gasLimit — WP owns gas.
+ *
+ * @param to      Recipient of confidential tokens (checksummed / lowercased accepted)
+ * @param amount  Underlying ERC-20 amount to wrap (base units); must be > 0
+ * @param rate    Optional on-chain wrapper `rate()` for uint64 validation
+ * @returns ABI-encoded calldata hex string (0x-prefixed)
+ * @throws {Error} if address/amount/rate is invalid or amount × rate exceeds uint64
+ */
+export declare function buildWrapCalldata(to: string, amount: string | number | bigint, rate?: string | number | bigint): string;
+/**
+ * Decodes ERC-7984 `wrap(to, amount)` calldata.
+ *
+ * @param data ABI-encoded wrap calldata (0x-prefixed)
+ * @returns `{ to, amount }` with checksummed `to` and decimal-string `amount`
+ */
+export declare function decodeWrapCalldata(data: string): {
+    to: string;
+    amount: string;
+};
+/**
+ * Encodes ERC-7984 `unwrap(from, to, encryptedAmount, inputProof)` calldata for unshield.
+ *
+ * Calldata is sent to the confidential wrapper. Phase-1 unshield is self-directed:
+ * `from` and `to` are both the wallet base address. `encryptedAmount` is the
+ * FHE-encrypted burn amount (bytes32 handle) and `inputProof` is the Zama
+ * encryption proof — both produced by WP `ZamaRelayerService.encryptAmount`.
+ *
+ * Does not set gasLimit — WP owns gas.
+ *
+ * @param from             Source of confidential balance (base address)
+ * @param to               Recipient of released ERC-20 (base address in v1)
+ * @param encryptedAmount  bytes32 encrypted amount handle (0x-prefixed)
+ * @param inputProof       Encryption input proof bytes (0x-prefixed)
+ * @returns ABI-encoded calldata hex string (0x-prefixed)
+ * @throws {Error} if addresses or ciphertext fields are invalid
+ */
+export declare function buildUnwrapCalldata(from: string, to: string, encryptedAmount: string, inputProof: string): string;
+/**
+ * Decodes ERC-7984 `unwrap(from, to, encryptedAmount, inputProof)` calldata.
+ *
+ * @param data ABI-encoded unwrap calldata (0x-prefixed)
+ */
+export declare function decodeUnwrapCalldata(data: string): {
+    from: string;
+    to: string;
+    encryptedAmount: string;
+    inputProof: string;
+};
+/**
+ * Encodes ERC-7984 `finalizeUnwrap(requestId, cleartextAmount, decryptionProof)` calldata.
+ *
+ * Calldata is sent to the confidential wrapper to complete unshield phase-2 after
+ * the Zama oracle returns a cleartext amount and decryption proof for the unwrap
+ * request created in phase-1.
+ *
+ * Does not set gasLimit — WP owns gas.
+ *
+ * @param requestId         bytes32 unwrap request id (0x-prefixed)
+ * @param cleartextAmount   Decrypted confidential amount (uint64 domain); must be > 0
+ * @param decryptionProof   Oracle decryption proof bytes (0x-prefixed)
+ * @returns ABI-encoded calldata hex string (0x-prefixed)
+ * @throws {Error} if requestId, amount, or proof is invalid
+ */
+export declare function buildFinalizeUnwrapCalldata(requestId: string, cleartextAmount: string | number | bigint, decryptionProof: string): string;
+/**
+ * Decodes ERC-7984 `finalizeUnwrap(requestId, cleartextAmount, decryptionProof)` calldata.
+ *
+ * @param data ABI-encoded finalizeUnwrap calldata (0x-prefixed)
+ */
+export declare function decodeFinalizeUnwrapCalldata(data: string): {
+    requestId: string;
+    cleartextAmount: string;
+    decryptionProof: string;
+};
 /**
  * Encodes a single ACL.delegateForUserDecryption() call.
  *

package/dist/src/lib/zamaUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zamaUtils.d.ts","sourceRoot":"","sources":["../../../src/lib/zamaUtils.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,8BAA8B,2CAA4C,CAAC;AACxF,eAAO,MAAM,mBAAmB,0CAA2C,CAAC;AAC5E,eAAO,MAAM,iBAAiB,sBAAuB,CAAC;AACtD,eAAO,MAAM,YAAY,iCAAkC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,iCAAiC,QAE7C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAEhC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,QAElC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAmF,CAAC;AAMhH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAqBrG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,eAAe,EAAE,MAAM,EACvB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,MAAM,GACtB,MAAM,CAOR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gCAAgC,CAC9C,eAAe,EAAE,MAAM,EACvB,sBAAsB,EAAE,MAAM,EAAE,EAChC,eAAe,EAAE,MAAM,GACtB,MAAM,CAyBR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWpF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0CAA0C,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAyCrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,yCAAyC,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAK5G;AAED;;;;;;;;;GASG;AACH,wBAAgB,uCAAuC,CACrD,oBAAoB,EAAE,MAAM,EAC5B,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,MAAM,GACtB,MAAM,CAGR;AAED;;;;;;;GAOG;AACH,wBAAgB,wCAAwC,CAAC,IAAI,EAAE,MAAM,GAAG;IACtE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB,CA8BA"}
+{"version":3,"file":"zamaUtils.d.ts","sourceRoot":"","sources":["../../../src/lib/zamaUtils.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/zamaUtils.js

@@ -3,8 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.approveMethodId = exports.callFromParentMethodId = exports.aclMulticallMethodId = exports.delegateForUserDecryptionMethodId = exports.approveTypes = exports.aclMulticallTypes = exports.callFromParentTypes = exports.delegateForUserDecryptionTypes = void 0;
+exports.finalizeUnwrapMethodId = exports.unwrapMethodId = exports.wrapMethodId = exports.approveMethodId = exports.callFromParentMethodId = exports.aclMulticallMethodId = exports.delegateForUserDecryptionMethodId = exports.UINT64_MAX = exports.finalizeUnwrapTypes = exports.unwrapTypes = exports.wrapTypes = exports.approveTypes = exports.aclMulticallTypes = exports.callFromParentTypes = exports.delegateForUserDecryptionTypes = void 0;
+exports.assertAmountTimesRateFitsUint64 = assertAmountTimesRateFitsUint64;
 exports.buildApproveCalldata = buildApproveCalldata;
+exports.buildWrapCalldata = buildWrapCalldata;
+exports.decodeWrapCalldata = decodeWrapCalldata;
+exports.buildUnwrapCalldata = buildUnwrapCalldata;
+exports.decodeUnwrapCalldata = decodeUnwrapCalldata;
+exports.buildFinalizeUnwrapCalldata = buildFinalizeUnwrapCalldata;
+exports.decodeFinalizeUnwrapCalldata = decodeFinalizeUnwrapCalldata;
 exports.buildDelegationCalldata = buildDelegationCalldata;
 exports.buildMulticallDelegationCalldata = buildMulticallDelegationCalldata;
 exports.wrapInCallFromParent = wrapInCallFromParent;
@@ -24,6 +31,11 @@ exports.delegateForUserDecryptionTypes = ['address', 'address', 'uint64'];
 exports.callFromParentTypes = ['address', 'uint256', 'bytes'];
 exports.aclMulticallTypes = ['bytes[]'];
 exports.approveTypes = ['address', 'uint256'];
+exports.wrapTypes = ['address', 'uint256'];
+exports.unwrapTypes = ['address', 'address', 'bytes32', 'bytes'];
+exports.finalizeUnwrapTypes = ['bytes32', 'uint64', 'bytes'];
+/** Max value for Solidity `uint64` / ERC-7984 confidential amount domain (`euint64`). */
+exports.UINT64_MAX = 18446744073709551615n;
 /**
  * Function selector for ACL.delegateForUserDecryption(address,address,uint64)
  * = keccak256('delegateForUserDecryption(address,address,uint64)')[0:4]
@@ -46,9 +58,57 @@ exports.callFromParentMethodId = (0, ethereumjs_util_1.addHexPrefix)(ethereumjs_
  * Used for exact-amount (and approve(0) reset) approvals of the ERC-7984 wrapper as spender.
  */
 exports.approveMethodId = (0, ethereumjs_util_1.addHexPrefix)(ethereumjs_abi_1.default.methodID('approve', [...exports.approveTypes]).toString('hex'));
+/**
+ * Function selector for ERC-7984 wrap(address,uint256)
+ * = keccak256('wrap(address,uint256)')[0:4]
+ * Locks underlying ERC-20 in the wrapper and mints an encrypted balance to `to`.
+ */
+exports.wrapMethodId = (0, ethereumjs_util_1.addHexPrefix)(ethereumjs_abi_1.default.methodID('wrap', [...exports.wrapTypes]).toString('hex'));
+/**
+ * Function selector for ERC-7984 unwrap(address,address,bytes32,bytes)
+ * = keccak256('unwrap(address,address,bytes32,bytes)')[0:4]
+ * Burns confidential balance and requests release of underlying ERC-20 escrow.
+ */
+exports.unwrapMethodId = (0, ethereumjs_util_1.addHexPrefix)(ethereumjs_abi_1.default.methodID('unwrap', [...exports.unwrapTypes]).toString('hex'));
+/**
+ * Function selector for ERC-7984 finalizeUnwrap(bytes32,uint64,bytes)
+ * = keccak256('finalizeUnwrap(bytes32,uint64,bytes)')[0:4]
+ * Completes unshield after oracle decryption of the phase-1 unwrap request.
+ */
+exports.finalizeUnwrapMethodId = (0, ethereumjs_util_1.addHexPrefix)(ethereumjs_abi_1.default.methodID('finalizeUnwrap', [...exports.finalizeUnwrapTypes]).toString('hex'));
 // ---------------------------------------------------------------------------
 // Encoding functions
 // ---------------------------------------------------------------------------
+/**
+ * Asserts that `amount * rate` fits in uint64 (ERC-7984 confidential mint domain).
+ *
+ * @throws {Error} if amount or rate is invalid, or the product exceeds uint64
+ */
+function assertAmountTimesRateFitsUint64(amount, rate) {
+    let amountBn;
+    let rateBn;
+    try {
+        amountBn = typeof amount === 'bigint' ? amount : BigInt(amount);
+    }
+    catch {
+        throw new Error(`assertAmountTimesRateFitsUint64: invalid amount '${amount}'`);
+    }
+    try {
+        rateBn = typeof rate === 'bigint' ? rate : BigInt(rate);
+    }
+    catch {
+        throw new Error(`assertAmountTimesRateFitsUint64: invalid rate '${rate}'`);
+    }
+    if (amountBn <= 0n) {
+        throw new Error('assertAmountTimesRateFitsUint64: amount must be > 0');
+    }
+    if (rateBn <= 0n) {
+        throw new Error('assertAmountTimesRateFitsUint64: rate must be > 0');
+    }
+    if (amountBn * rateBn > exports.UINT64_MAX) {
+        throw new Error('assertAmountTimesRateFitsUint64: amount × rate exceeds uint64');
+    }
+}
 /**
  * Encodes ERC-20 `approve(spender, amount)` calldata for ERC-7984 shield.
  *
@@ -86,6 +146,180 @@ function buildApproveCalldata(wrapperAddress, amount) {
     const args = ethereumjs_abi_1.default.rawEncode([...exports.approveTypes], [checksummedWrapper, amountBn.toString()]);
     return (0, ethereumjs_util_1.addHexPrefix)(Buffer.concat([method, args]).toString('hex'));
 }
+/**
+ * Encodes ERC-7984 `wrap(to, amount)` calldata for the shield path.
+ *
+ * Calldata is sent to the confidential wrapper contract. `to` is the recipient of
+ * the minted encrypted balance (self-directed shields use the wallet base address).
+ * When `rate` is provided, validates that `amount × rate` fits uint64 (`euint64`).
+ * `rate` is not encoded in calldata (deserialize round-trips omit it).
+ *
+ * Does not set gasLimit — WP owns gas.
+ *
+ * @param to      Recipient of confidential tokens (checksummed / lowercased accepted)
+ * @param amount  Underlying ERC-20 amount to wrap (base units); must be > 0
+ * @param rate    Optional on-chain wrapper `rate()` for uint64 validation
+ * @returns ABI-encoded calldata hex string (0x-prefixed)
+ * @throws {Error} if address/amount/rate is invalid or amount × rate exceeds uint64
+ */
+function buildWrapCalldata(to, amount, rate) {
+    let checksummedTo;
+    try {
+        checksummedTo = ethers_1.ethers.utils.getAddress(to);
+    }
+    catch {
+        throw new Error(`buildWrapCalldata: invalid to address '${to}'`);
+    }
+    let amountBn;
+    try {
+        amountBn = typeof amount === 'bigint' ? amount : BigInt(amount);
+    }
+    catch {
+        throw new Error(`buildWrapCalldata: invalid amount '${amount}'`);
+    }
+    if (amountBn <= 0n) {
+        throw new Error('buildWrapCalldata: amount must be > 0');
+    }
+    if (rate !== undefined) {
+        assertAmountTimesRateFitsUint64(amountBn, rate);
+    }
+    const method = ethereumjs_abi_1.default.methodID('wrap', [...exports.wrapTypes]);
+    const args = ethereumjs_abi_1.default.rawEncode([...exports.wrapTypes], [checksummedTo, amountBn.toString()]);
+    return (0, ethereumjs_util_1.addHexPrefix)(Buffer.concat([method, args]).toString('hex'));
+}
+/**
+ * Decodes ERC-7984 `wrap(to, amount)` calldata.
+ *
+ * @param data ABI-encoded wrap calldata (0x-prefixed)
+ * @returns `{ to, amount }` with checksummed `to` and decimal-string `amount`
+ */
+function decodeWrapCalldata(data) {
+    if (!data.toLowerCase().startsWith(exports.wrapMethodId.toLowerCase())) {
+        throw new Error(`decodeWrapCalldata: expected wrap selector ${exports.wrapMethodId}, got ${data.slice(0, 10)}`);
+    }
+    const abiCoder = new ethers_1.ethers.utils.AbiCoder();
+    const decoded = abiCoder.decode([...exports.wrapTypes], '0x' + data.slice(10));
+    return {
+        to: ethers_1.ethers.utils.getAddress(decoded[0]),
+        amount: decoded[1].toString(),
+    };
+}
+/**
+ * Encodes ERC-7984 `unwrap(from, to, encryptedAmount, inputProof)` calldata for unshield.
+ *
+ * Calldata is sent to the confidential wrapper. Phase-1 unshield is self-directed:
+ * `from` and `to` are both the wallet base address. `encryptedAmount` is the
+ * FHE-encrypted burn amount (bytes32 handle) and `inputProof` is the Zama
+ * encryption proof — both produced by WP `ZamaRelayerService.encryptAmount`.
+ *
+ * Does not set gasLimit — WP owns gas.
+ *
+ * @param from             Source of confidential balance (base address)
+ * @param to               Recipient of released ERC-20 (base address in v1)
+ * @param encryptedAmount  bytes32 encrypted amount handle (0x-prefixed)
+ * @param inputProof       Encryption input proof bytes (0x-prefixed)
+ * @returns ABI-encoded calldata hex string (0x-prefixed)
+ * @throws {Error} if addresses or ciphertext fields are invalid
+ */
+function buildUnwrapCalldata(from, to, encryptedAmount, inputProof) {
+    let checksummedFrom;
+    let checksummedTo;
+    try {
+        checksummedFrom = ethers_1.ethers.utils.getAddress(from);
+    }
+    catch {
+        throw new Error(`buildUnwrapCalldata: invalid from address '${from}'`);
+    }
+    try {
+        checksummedTo = ethers_1.ethers.utils.getAddress(to);
+    }
+    catch {
+        throw new Error(`buildUnwrapCalldata: invalid to address '${to}'`);
+    }
+    if (!ethers_1.ethers.utils.isHexString(encryptedAmount) || ethers_1.ethers.utils.hexDataLength(encryptedAmount) !== 32) {
+        throw new Error(`buildUnwrapCalldata: encryptedAmount must be a 32-byte hex string, got '${encryptedAmount}'`);
+    }
+    if (!ethers_1.ethers.utils.isHexString(inputProof) || ethers_1.ethers.utils.hexDataLength(inputProof) === 0) {
+        throw new Error(`buildUnwrapCalldata: inputProof must be a non-empty hex string, got '${inputProof}'`);
+    }
+    const method = ethereumjs_abi_1.default.methodID('unwrap', [...exports.unwrapTypes]);
+    const args = ethereumjs_abi_1.default.rawEncode([...exports.unwrapTypes], [checksummedFrom, checksummedTo, (0, ethereumjs_util_1.toBuffer)(encryptedAmount), (0, ethereumjs_util_1.toBuffer)(inputProof)]);
+    return (0, ethereumjs_util_1.addHexPrefix)(Buffer.concat([method, args]).toString('hex'));
+}
+/**
+ * Decodes ERC-7984 `unwrap(from, to, encryptedAmount, inputProof)` calldata.
+ *
+ * @param data ABI-encoded unwrap calldata (0x-prefixed)
+ */
+function decodeUnwrapCalldata(data) {
+    if (!data.toLowerCase().startsWith(exports.unwrapMethodId.toLowerCase())) {
+        throw new Error(`decodeUnwrapCalldata: expected unwrap selector ${exports.unwrapMethodId}, got ${data.slice(0, 10)}`);
+    }
+    const abiCoder = new ethers_1.ethers.utils.AbiCoder();
+    const decoded = abiCoder.decode([...exports.unwrapTypes], '0x' + data.slice(10));
+    return {
+        from: ethers_1.ethers.utils.getAddress(decoded[0]),
+        to: ethers_1.ethers.utils.getAddress(decoded[1]),
+        encryptedAmount: ethers_1.ethers.utils.hexlify(decoded[2]),
+        inputProof: ethers_1.ethers.utils.hexlify(decoded[3]),
+    };
+}
+/**
+ * Encodes ERC-7984 `finalizeUnwrap(requestId, cleartextAmount, decryptionProof)` calldata.
+ *
+ * Calldata is sent to the confidential wrapper to complete unshield phase-2 after
+ * the Zama oracle returns a cleartext amount and decryption proof for the unwrap
+ * request created in phase-1.
+ *
+ * Does not set gasLimit — WP owns gas.
+ *
+ * @param requestId         bytes32 unwrap request id (0x-prefixed)
+ * @param cleartextAmount   Decrypted confidential amount (uint64 domain); must be > 0
+ * @param decryptionProof   Oracle decryption proof bytes (0x-prefixed)
+ * @returns ABI-encoded calldata hex string (0x-prefixed)
+ * @throws {Error} if requestId, amount, or proof is invalid
+ */
+function buildFinalizeUnwrapCalldata(requestId, cleartextAmount, decryptionProof) {
+    if (!ethers_1.ethers.utils.isHexString(requestId) || ethers_1.ethers.utils.hexDataLength(requestId) !== 32) {
+        throw new Error(`buildFinalizeUnwrapCalldata: requestId must be a 32-byte hex string, got '${requestId}'`);
+    }
+    let amountBn;
+    try {
+        amountBn = typeof cleartextAmount === 'bigint' ? cleartextAmount : BigInt(cleartextAmount);
+    }
+    catch {
+        throw new Error(`buildFinalizeUnwrapCalldata: invalid cleartextAmount '${cleartextAmount}'`);
+    }
+    if (amountBn <= 0n) {
+        throw new Error('buildFinalizeUnwrapCalldata: cleartextAmount must be > 0');
+    }
+    if (amountBn > exports.UINT64_MAX) {
+        throw new Error('buildFinalizeUnwrapCalldata: cleartextAmount exceeds uint64');
+    }
+    if (!ethers_1.ethers.utils.isHexString(decryptionProof) || ethers_1.ethers.utils.hexDataLength(decryptionProof) === 0) {
+        throw new Error(`buildFinalizeUnwrapCalldata: decryptionProof must be a non-empty hex string, got '${decryptionProof}'`);
+    }
+    const method = ethereumjs_abi_1.default.methodID('finalizeUnwrap', [...exports.finalizeUnwrapTypes]);
+    const args = ethereumjs_abi_1.default.rawEncode([...exports.finalizeUnwrapTypes], [(0, ethereumjs_util_1.toBuffer)(requestId), amountBn.toString(), (0, ethereumjs_util_1.toBuffer)(decryptionProof)]);
+    return (0, ethereumjs_util_1.addHexPrefix)(Buffer.concat([method, args]).toString('hex'));
+}
+/**
+ * Decodes ERC-7984 `finalizeUnwrap(requestId, cleartextAmount, decryptionProof)` calldata.
+ *
+ * @param data ABI-encoded finalizeUnwrap calldata (0x-prefixed)
+ */
+function decodeFinalizeUnwrapCalldata(data) {
+    if (!data.toLowerCase().startsWith(exports.finalizeUnwrapMethodId.toLowerCase())) {
+        throw new Error(`decodeFinalizeUnwrapCalldata: expected finalizeUnwrap selector ${exports.finalizeUnwrapMethodId}, got ${data.slice(0, 10)}`);
+    }
+    const abiCoder = new ethers_1.ethers.utils.AbiCoder();
+    const decoded = abiCoder.decode([...exports.finalizeUnwrapTypes], '0x' + data.slice(10));
+    return {
+        requestId: ethers_1.ethers.utils.hexlify(decoded[0]),
+        cleartextAmount: decoded[1].toString(),
+        decryptionProof: ethers_1.ethers.utils.hexlify(decoded[2]),
+    };
+}
 /**
  * Encodes a single ACL.delegateForUserDecryption() call.
  *
@@ -262,4 +496,4 @@ function decodeFlushERC7984ForwarderTokenCalldata(data) {
         encryptedHandle,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zamaUtils.js","sourceRoot":"","sources":["../../../src/lib/zamaUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import { addHexPrefix, bufferToHex, toBuffer } from 'ethereumjs-util';\nimport EthereumAbi from 'ethereumjs-abi';\nimport { ethers } from 'ethers';\nimport { confidentialTransferNoProofMethodId, confidentialTransferNoProofTypes } from './walletUtil';\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\n// ABI parameter type arrays\nexport const delegateForUserDecryptionTypes = ['address', 'address', 'uint64'] as const;\nexport const callFromParentTypes = ['address', 'uint256', 'bytes'] as const;\nexport const aclMulticallTypes = ['bytes[]'] as const;\nexport const approveTypes = ['address', 'uint256'] as const;\n\n/**\n * Function selector for ACL.delegateForUserDecryption(address,address,uint64)\n * = keccak256('delegateForUserDecryption(address,address,uint64)')[0:4]\n */\nexport const delegateForUserDecryptionMethodId = addHexPrefix(\n  EthereumAbi.methodID('delegateForUserDecryption', [...delegateForUserDecryptionTypes]).toString('hex')\n);\n\n/**\n * Function selector for ACL.multicall(bytes[])\n * = keccak256('multicall(bytes[])')[0:4]\n * ACL inherits OpenZeppelin MulticallUpgradeable — preserves msg.sender via delegatecall.\n */\nexport const aclMulticallMethodId = addHexPrefix(\n  EthereumAbi.methodID('multicall', [...aclMulticallTypes]).toString('hex')\n);\n\n/**\n * Function selector for ForwarderV4.callFromParent(address,uint256,bytes)\n * = keccak256('callFromParent(address,uint256,bytes)')[0:4]\n */\nexport const callFromParentMethodId = addHexPrefix(\n  EthereumAbi.methodID('callFromParent', [...callFromParentTypes]).toString('hex')\n);\n\n/**\n * Function selector for ERC-20 approve(address,uint256)\n * = keccak256('approve(address,uint256)')[0:4]\n * Used for exact-amount (and approve(0) reset) approvals of the ERC-7984 wrapper as spender.\n */\nexport const approveMethodId = addHexPrefix(EthereumAbi.methodID('approve', [...approveTypes]).toString('hex'));\n\n// ---------------------------------------------------------------------------\n// Encoding functions\n// ---------------------------------------------------------------------------\n\n/**\n * Encodes ERC-20 `approve(spender, amount)` calldata for ERC-7984 shield.\n *\n * The spender is the confidential wrapper contract; the resulting calldata is\n * sent to the underlying ERC-20. Exact-amount approve is used for the shield\n * path; `amount = 0` is the USDT-style allowance reset used when\n * `requiresApprovalReset` is set on the wrapper pair.\n *\n * Does not set gasLimit — WP owns gas.\n *\n * @param wrapperAddress  ERC-7984 wrapper contract (spender)\n * @param amount          Exact allowance to set (base units); `0` for reset\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n * @throws {Error} if the wrapper address is invalid or amount is negative\n */\nexport function buildApproveCalldata(wrapperAddress: string, amount: string | number | bigint): string {\n  let checksummedWrapper: string;\n  try {\n    checksummedWrapper = ethers.utils.getAddress(wrapperAddress);\n  } catch {\n    throw new Error(`buildApproveCalldata: invalid wrapper address '${wrapperAddress}'`);\n  }\n\n  let amountBn: bigint;\n  try {\n    amountBn = typeof amount === 'bigint' ? amount : BigInt(amount);\n  } catch {\n    throw new Error(`buildApproveCalldata: invalid amount '${amount}'`);\n  }\n  if (amountBn < 0n) {\n    throw new Error('buildApproveCalldata: amount must be >= 0');\n  }\n\n  const method = EthereumAbi.methodID('approve', [...approveTypes]);\n  const args = EthereumAbi.rawEncode([...approveTypes], [checksummedWrapper, amountBn.toString()]);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Encodes a single ACL.delegateForUserDecryption() call.\n *\n * Grants `delegateAddress` the right to decrypt ERC-7984 token balances on\n * behalf of the calling address (msg.sender) for the specified token contract.\n *\n * @param delegateAddress       BitGo enterprise viewing key address\n * @param tokenContractAddress  ERC-7984 token contract address\n * @param expiryTimestamp       Unix seconds; recommended: Math.floor(Date.now()/1000) + 365*86400\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n */\nexport function buildDelegationCalldata(\n  delegateAddress: string,\n  tokenContractAddress: string,\n  expiryTimestamp: number\n): string {\n  const method = EthereumAbi.methodID('delegateForUserDecryption', [...delegateForUserDecryptionTypes]);\n  const args = EthereumAbi.rawEncode(\n    [...delegateForUserDecryptionTypes],\n    [delegateAddress, tokenContractAddress, expiryTimestamp]\n  );\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Encodes N delegateForUserDecryption calls batched inside ACL.multicall().\n *\n * Produces a single TX that grants delegation for all specified token contracts.\n * Requires tokenContractAddresses.length >= 1.\n * Note: DecryptionDelegationBuilder always uses this function (even for a single token)\n * to keep the transaction shape consistent regardless of token count.\n *\n * @param delegateAddress          BitGo enterprise viewing key address\n * @param tokenContractAddresses   Array of ERC-7984 token contract addresses\n * @param expiryTimestamp          Unix seconds\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n */\nexport function buildMulticallDelegationCalldata(\n  delegateAddress: string,\n  tokenContractAddresses: string[],\n  expiryTimestamp: number\n): string {\n  if (tokenContractAddresses.length === 0) {\n    throw new Error('buildMulticallDelegationCalldata: tokenContractAddresses must not be empty');\n  }\n\n  // Build each inner delegateForUserDecryption call as raw bytes\n  const innerCalls: Buffer[] = tokenContractAddresses.map((tokenAddress) => {\n    const innerMethod = EthereumAbi.methodID('delegateForUserDecryption', [...delegateForUserDecryptionTypes]);\n    const innerArgs = EthereumAbi.rawEncode(\n      [...delegateForUserDecryptionTypes],\n      [delegateAddress, tokenAddress, expiryTimestamp]\n    );\n    return Buffer.concat([innerMethod, innerArgs]);\n  });\n\n  // Encode outer multicall(bytes[])\n  // ethereumjs-abi v0.6.x has a bug where it omits the per-element offset table\n  // for bytes[], producing malformed calldata that on-chain ABI decoders reject.\n  // Use ethers AbiCoder which correctly emits the head offset words.\n  const outerMethod = EthereumAbi.methodID('multicall', [...aclMulticallTypes]);\n  const outerArgs = Buffer.from(\n    new ethers.utils.AbiCoder().encode([...aclMulticallTypes], [innerCalls]).slice(2),\n    'hex'\n  );\n  return addHexPrefix(Buffer.concat([outerMethod, outerArgs]).toString('hex'));\n}\n\n/**\n * Wraps calldata in a ForwarderV4.callFromParent(target, 0, data) call.\n *\n * Used when a forwarder contract must be msg.sender for an external contract\n * call — for example, when the forwarder itself needs to call\n * ACL.delegateForUserDecryption() so that its own balance can be decrypted.\n *\n * Only the parentAddress (root wallet) is allowed to call callFromParent\n * (enforced by the forwarder's onlyParent modifier).\n *\n * @param targetAddress  Address of the contract the forwarder will call (e.g. ACL)\n * @param calldata       ABI-encoded inner calldata (e.g. from buildDelegationCalldata)\n * @returns ABI-encoded callFromParent calldata hex string (0x-prefixed)\n */\nexport function wrapInCallFromParent(targetAddress: string, calldata: string): string {\n  const method = EthereumAbi.methodID('callFromParent', [...callFromParentTypes]);\n  const args = EthereumAbi.rawEncode(\n    [...callFromParentTypes],\n    [\n      targetAddress,\n      0, // value: no ETH transfer\n      toBuffer(calldata), // inner calldata as bytes\n    ]\n  );\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Decodes token contract addresses from delegation calldata.\n *\n * Handles two shapes of calldata:\n *   - Direct ACL.multicall(bytes[]) (root wallet path)\n *   - ForwarderV4.callFromParent(address, uint256, bytes) wrapping a multicall (forwarder path)\n *\n * @param calldata  ABI-encoded delegation calldata (0x-prefixed or raw hex)\n * @returns Array of token contract addresses (lowercase) found in the delegation calls\n * @throws {Error} if the calldata does not start with a recognised method selector\n */\nexport function decodeTokenAddressesFromDelegationCalldata(calldata: string): string[] {\n  const data = calldata.startsWith('0x') ? calldata : '0x' + calldata;\n  const methodId = data.slice(0, 10);\n  const abiCoder = new ethers.utils.AbiCoder();\n\n  let multicallHex: string;\n\n  if (methodId === callFromParentMethodId) {\n    // Decode callFromParent(address, uint256, bytes) — inner bytes is the full multicall calldata.\n    // ethers v5 returns `bytes` as a hex string; use hexlify to normalise to a 0x-prefixed hex string\n    // regardless of whether the runtime returns a string or a Uint8Array.\n    const decoded = abiCoder.decode([...callFromParentTypes], '0x' + data.slice(10));\n    multicallHex = ethers.utils.hexlify(decoded[2]);\n  } else if (methodId === aclMulticallMethodId) {\n    multicallHex = data;\n  } else {\n    throw new Error('Not a valid delegation calldata');\n  }\n\n  if (multicallHex.slice(0, 10) !== aclMulticallMethodId) {\n    throw new Error('Not a valid delegation calldata');\n  }\n\n  // Decode multicall(bytes[]) — each element is an inner delegateForUserDecryption call.\n  // ethers v5 returns bytes[] elements as hex strings; use hexlify to normalise each element.\n  const decoded = abiCoder.decode(['bytes[]'], '0x' + multicallHex.slice(10));\n  const innerCalls: unknown[] = decoded[0];\n\n  const tokenAddresses: string[] = [];\n  for (const innerCall of innerCalls) {\n    const innerHex = ethers.utils.hexlify(innerCall as ethers.utils.BytesLike).slice(2); // strip 0x\n    const innerMethodId = '0x' + innerHex.slice(0, 8);\n    if (innerMethodId !== delegateForUserDecryptionMethodId) {\n      continue;\n    }\n    // Decode delegateForUserDecryption(address delegate, address tokenAddress, uint64 expiry)\n    const innerDecoded = abiCoder.decode([...delegateForUserDecryptionTypes], '0x' + innerHex.slice(8));\n    tokenAddresses.push((innerDecoded[1] as string).toLowerCase());\n  }\n\n  return tokenAddresses;\n}\n\n/**\n * Encodes confidentialTransfer(address to, bytes32 encryptedHandle) calldata.\n * Uses the no-proof variant (selector 0x5bebed7e) — valid when the caller (forwarder)\n * is already ACL-allowed on the handle from when it received the tokens.\n *\n * @param toAddress       Address that will receive the tokens\n * @param encryptedHandle bytes32 encrypted balance handle from confidentialBalanceOf\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n */\nexport function buildConfidentialTransferByHandleCalldata(toAddress: string, encryptedHandle: string): string {\n  const method = Buffer.from(confidentialTransferNoProofMethodId.slice(2), 'hex');\n  const handleBuffer = toBuffer(encryptedHandle);\n  const args = EthereumAbi.rawEncode([...confidentialTransferNoProofTypes], [toAddress, handleBuffer]);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Encodes the full flush calldata for ERC-7984 forwarder consolidation:\n *   callFromParent(tokenContractAddress, 0, confidentialTransfer(parentAddress, encryptedHandle))\n * The forwarder executes the inner confidentialTransfer with msg.sender = forwarder.\n *\n * @param tokenContractAddress  ERC-7984 token contract address\n * @param parentAddress         Root wallet address (destination of flushed tokens)\n * @param encryptedHandle       bytes32 encrypted balance handle from confidentialBalanceOf\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n */\nexport function buildFlushERC7984ForwarderTokenCalldata(\n  tokenContractAddress: string,\n  parentAddress: string,\n  encryptedHandle: string\n): string {\n  const innerCalldata = buildConfidentialTransferByHandleCalldata(parentAddress, encryptedHandle);\n  return wrapInCallFromParent(tokenContractAddress, innerCalldata);\n}\n\n/**\n * Decodes a FlushERC7984ForwarderToken calldata.\n * Strips the outer callFromParent wrapper and the inner confidentialTransfer.\n * Returns { tokenContractAddress, parentAddress, encryptedHandle }.\n *\n * @param data  ABI-encoded flush calldata (0x-prefixed)\n * @returns Decoded fields\n */\nexport function decodeFlushERC7984ForwarderTokenCalldata(data: string): {\n  tokenContractAddress: string;\n  parentAddress: string;\n  encryptedHandle: string;\n} {\n  if (!data.startsWith(callFromParentMethodId)) {\n    throw new Error(\n      `Invalid FlushERC7984ForwarderToken calldata: expected callFromParent selector, got ${data.slice(0, 10)}`\n    );\n  }\n\n  const abiCoder = new ethers.utils.AbiCoder();\n  const outerDecoded = abiCoder.decode([...callFromParentTypes], '0x' + data.slice(10));\n  const tokenContractAddress: string = outerDecoded[0];\n  const innerCalldata: string = ethers.utils.hexlify(outerDecoded[2]);\n\n  if (!innerCalldata.startsWith(confidentialTransferNoProofMethodId)) {\n    throw new Error(\n      `Invalid FlushERC7984ForwarderToken inner calldata: expected confidentialTransfer selector, got ${innerCalldata.slice(\n        0,\n        10\n      )}`\n    );\n  }\n\n  const innerDecoded = abiCoder.decode([...confidentialTransferNoProofTypes], '0x' + innerCalldata.slice(10));\n  const parentAddress: string = innerDecoded[0];\n  const encryptedHandle: string = bufferToHex(toBuffer(innerDecoded[1]));\n\n  return {\n    tokenContractAddress,\n    parentAddress,\n    encryptedHandle,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zamaUtils.js","sourceRoot":"","sources":["../../../src/lib/zamaUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import { addHexPrefix, bufferToHex, toBuffer } from 'ethereumjs-util';\nimport EthereumAbi from 'ethereumjs-abi';\nimport { ethers } from 'ethers';\nimport { confidentialTransferNoProofMethodId, confidentialTransferNoProofTypes } from './walletUtil';\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\n// ABI parameter type arrays\nexport const delegateForUserDecryptionTypes = ['address', 'address', 'uint64'] as const;\nexport const callFromParentTypes = ['address', 'uint256', 'bytes'] as const;\nexport const aclMulticallTypes = ['bytes[]'] as const;\nexport const approveTypes = ['address', 'uint256'] as const;\nexport const wrapTypes = ['address', 'uint256'] as const;\nexport const unwrapTypes = ['address', 'address', 'bytes32', 'bytes'] as const;\nexport const finalizeUnwrapTypes = ['bytes32', 'uint64', 'bytes'] as const;\n\n/** Max value for Solidity `uint64` / ERC-7984 confidential amount domain (`euint64`). */\nexport const UINT64_MAX = 18446744073709551615n;\n/**\n * Function selector for ACL.delegateForUserDecryption(address,address,uint64)\n * = keccak256('delegateForUserDecryption(address,address,uint64)')[0:4]\n */\nexport const delegateForUserDecryptionMethodId = addHexPrefix(\n  EthereumAbi.methodID('delegateForUserDecryption', [...delegateForUserDecryptionTypes]).toString('hex')\n);\n\n/**\n * Function selector for ACL.multicall(bytes[])\n * = keccak256('multicall(bytes[])')[0:4]\n * ACL inherits OpenZeppelin MulticallUpgradeable — preserves msg.sender via delegatecall.\n */\nexport const aclMulticallMethodId = addHexPrefix(\n  EthereumAbi.methodID('multicall', [...aclMulticallTypes]).toString('hex')\n);\n\n/**\n * Function selector for ForwarderV4.callFromParent(address,uint256,bytes)\n * = keccak256('callFromParent(address,uint256,bytes)')[0:4]\n */\nexport const callFromParentMethodId = addHexPrefix(\n  EthereumAbi.methodID('callFromParent', [...callFromParentTypes]).toString('hex')\n);\n\n/**\n * Function selector for ERC-20 approve(address,uint256)\n * = keccak256('approve(address,uint256)')[0:4]\n * Used for exact-amount (and approve(0) reset) approvals of the ERC-7984 wrapper as spender.\n */\nexport const approveMethodId = addHexPrefix(EthereumAbi.methodID('approve', [...approveTypes]).toString('hex'));\n\n/**\n * Function selector for ERC-7984 wrap(address,uint256)\n * = keccak256('wrap(address,uint256)')[0:4]\n * Locks underlying ERC-20 in the wrapper and mints an encrypted balance to `to`.\n */\nexport const wrapMethodId = addHexPrefix(EthereumAbi.methodID('wrap', [...wrapTypes]).toString('hex'));\n\n/**\n * Function selector for ERC-7984 unwrap(address,address,bytes32,bytes)\n * = keccak256('unwrap(address,address,bytes32,bytes)')[0:4]\n * Burns confidential balance and requests release of underlying ERC-20 escrow.\n */\nexport const unwrapMethodId = addHexPrefix(EthereumAbi.methodID('unwrap', [...unwrapTypes]).toString('hex'));\n\n/**\n * Function selector for ERC-7984 finalizeUnwrap(bytes32,uint64,bytes)\n * = keccak256('finalizeUnwrap(bytes32,uint64,bytes)')[0:4]\n * Completes unshield after oracle decryption of the phase-1 unwrap request.\n */\nexport const finalizeUnwrapMethodId = addHexPrefix(\n  EthereumAbi.methodID('finalizeUnwrap', [...finalizeUnwrapTypes]).toString('hex')\n);\n\n// ---------------------------------------------------------------------------\n// Encoding functions\n// ---------------------------------------------------------------------------\n\n/**\n * Asserts that `amount * rate` fits in uint64 (ERC-7984 confidential mint domain).\n *\n * @throws {Error} if amount or rate is invalid, or the product exceeds uint64\n */\nexport function assertAmountTimesRateFitsUint64(\n  amount: string | number | bigint,\n  rate: string | number | bigint\n): void {\n  let amountBn: bigint;\n  let rateBn: bigint;\n  try {\n    amountBn = typeof amount === 'bigint' ? amount : BigInt(amount);\n  } catch {\n    throw new Error(`assertAmountTimesRateFitsUint64: invalid amount '${amount}'`);\n  }\n  try {\n    rateBn = typeof rate === 'bigint' ? rate : BigInt(rate);\n  } catch {\n    throw new Error(`assertAmountTimesRateFitsUint64: invalid rate '${rate}'`);\n  }\n  if (amountBn <= 0n) {\n    throw new Error('assertAmountTimesRateFitsUint64: amount must be > 0');\n  }\n  if (rateBn <= 0n) {\n    throw new Error('assertAmountTimesRateFitsUint64: rate must be > 0');\n  }\n  if (amountBn * rateBn > UINT64_MAX) {\n    throw new Error('assertAmountTimesRateFitsUint64: amount × rate exceeds uint64');\n  }\n}\n\n/**\n * Encodes ERC-20 `approve(spender, amount)` calldata for ERC-7984 shield.\n *\n * The spender is the confidential wrapper contract; the resulting calldata is\n * sent to the underlying ERC-20. Exact-amount approve is used for the shield\n * path; `amount = 0` is the USDT-style allowance reset used when\n * `requiresApprovalReset` is set on the wrapper pair.\n *\n * Does not set gasLimit — WP owns gas.\n *\n * @param wrapperAddress  ERC-7984 wrapper contract (spender)\n * @param amount          Exact allowance to set (base units); `0` for reset\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n * @throws {Error} if the wrapper address is invalid or amount is negative\n */\nexport function buildApproveCalldata(wrapperAddress: string, amount: string | number | bigint): string {\n  let checksummedWrapper: string;\n  try {\n    checksummedWrapper = ethers.utils.getAddress(wrapperAddress);\n  } catch {\n    throw new Error(`buildApproveCalldata: invalid wrapper address '${wrapperAddress}'`);\n  }\n\n  let amountBn: bigint;\n  try {\n    amountBn = typeof amount === 'bigint' ? amount : BigInt(amount);\n  } catch {\n    throw new Error(`buildApproveCalldata: invalid amount '${amount}'`);\n  }\n  if (amountBn < 0n) {\n    throw new Error('buildApproveCalldata: amount must be >= 0');\n  }\n\n  const method = EthereumAbi.methodID('approve', [...approveTypes]);\n  const args = EthereumAbi.rawEncode([...approveTypes], [checksummedWrapper, amountBn.toString()]);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Encodes ERC-7984 `wrap(to, amount)` calldata for the shield path.\n *\n * Calldata is sent to the confidential wrapper contract. `to` is the recipient of\n * the minted encrypted balance (self-directed shields use the wallet base address).\n * When `rate` is provided, validates that `amount × rate` fits uint64 (`euint64`).\n * `rate` is not encoded in calldata (deserialize round-trips omit it).\n *\n * Does not set gasLimit — WP owns gas.\n *\n * @param to      Recipient of confidential tokens (checksummed / lowercased accepted)\n * @param amount  Underlying ERC-20 amount to wrap (base units); must be > 0\n * @param rate    Optional on-chain wrapper `rate()` for uint64 validation\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n * @throws {Error} if address/amount/rate is invalid or amount × rate exceeds uint64\n */\nexport function buildWrapCalldata(\n  to: string,\n  amount: string | number | bigint,\n  rate?: string | number | bigint\n): string {\n  let checksummedTo: string;\n  try {\n    checksummedTo = ethers.utils.getAddress(to);\n  } catch {\n    throw new Error(`buildWrapCalldata: invalid to address '${to}'`);\n  }\n\n  let amountBn: bigint;\n  try {\n    amountBn = typeof amount === 'bigint' ? amount : BigInt(amount);\n  } catch {\n    throw new Error(`buildWrapCalldata: invalid amount '${amount}'`);\n  }\n  if (amountBn <= 0n) {\n    throw new Error('buildWrapCalldata: amount must be > 0');\n  }\n\n  if (rate !== undefined) {\n    assertAmountTimesRateFitsUint64(amountBn, rate);\n  }\n\n  const method = EthereumAbi.methodID('wrap', [...wrapTypes]);\n  const args = EthereumAbi.rawEncode([...wrapTypes], [checksummedTo, amountBn.toString()]);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Decodes ERC-7984 `wrap(to, amount)` calldata.\n *\n * @param data ABI-encoded wrap calldata (0x-prefixed)\n * @returns `{ to, amount }` with checksummed `to` and decimal-string `amount`\n */\nexport function decodeWrapCalldata(data: string): { to: string; amount: string } {\n  if (!data.toLowerCase().startsWith(wrapMethodId.toLowerCase())) {\n    throw new Error(`decodeWrapCalldata: expected wrap selector ${wrapMethodId}, got ${data.slice(0, 10)}`);\n  }\n  const abiCoder = new ethers.utils.AbiCoder();\n  const decoded = abiCoder.decode([...wrapTypes], '0x' + data.slice(10));\n  return {\n    to: ethers.utils.getAddress(decoded[0]),\n    amount: decoded[1].toString(),\n  };\n}\n\n/**\n * Encodes ERC-7984 `unwrap(from, to, encryptedAmount, inputProof)` calldata for unshield.\n *\n * Calldata is sent to the confidential wrapper. Phase-1 unshield is self-directed:\n * `from` and `to` are both the wallet base address. `encryptedAmount` is the\n * FHE-encrypted burn amount (bytes32 handle) and `inputProof` is the Zama\n * encryption proof — both produced by WP `ZamaRelayerService.encryptAmount`.\n *\n * Does not set gasLimit — WP owns gas.\n *\n * @param from             Source of confidential balance (base address)\n * @param to               Recipient of released ERC-20 (base address in v1)\n * @param encryptedAmount  bytes32 encrypted amount handle (0x-prefixed)\n * @param inputProof       Encryption input proof bytes (0x-prefixed)\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n * @throws {Error} if addresses or ciphertext fields are invalid\n */\nexport function buildUnwrapCalldata(from: string, to: string, encryptedAmount: string, inputProof: string): string {\n  let checksummedFrom: string;\n  let checksummedTo: string;\n  try {\n    checksummedFrom = ethers.utils.getAddress(from);\n  } catch {\n    throw new Error(`buildUnwrapCalldata: invalid from address '${from}'`);\n  }\n  try {\n    checksummedTo = ethers.utils.getAddress(to);\n  } catch {\n    throw new Error(`buildUnwrapCalldata: invalid to address '${to}'`);\n  }\n\n  if (!ethers.utils.isHexString(encryptedAmount) || ethers.utils.hexDataLength(encryptedAmount) !== 32) {\n    throw new Error(`buildUnwrapCalldata: encryptedAmount must be a 32-byte hex string, got '${encryptedAmount}'`);\n  }\n  if (!ethers.utils.isHexString(inputProof) || ethers.utils.hexDataLength(inputProof) === 0) {\n    throw new Error(`buildUnwrapCalldata: inputProof must be a non-empty hex string, got '${inputProof}'`);\n  }\n\n  const method = EthereumAbi.methodID('unwrap', [...unwrapTypes]);\n  const args = EthereumAbi.rawEncode(\n    [...unwrapTypes],\n    [checksummedFrom, checksummedTo, toBuffer(encryptedAmount), toBuffer(inputProof)]\n  );\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Decodes ERC-7984 `unwrap(from, to, encryptedAmount, inputProof)` calldata.\n *\n * @param data ABI-encoded unwrap calldata (0x-prefixed)\n */\nexport function decodeUnwrapCalldata(data: string): {\n  from: string;\n  to: string;\n  encryptedAmount: string;\n  inputProof: string;\n} {\n  if (!data.toLowerCase().startsWith(unwrapMethodId.toLowerCase())) {\n    throw new Error(`decodeUnwrapCalldata: expected unwrap selector ${unwrapMethodId}, got ${data.slice(0, 10)}`);\n  }\n  const abiCoder = new ethers.utils.AbiCoder();\n  const decoded = abiCoder.decode([...unwrapTypes], '0x' + data.slice(10));\n  return {\n    from: ethers.utils.getAddress(decoded[0]),\n    to: ethers.utils.getAddress(decoded[1]),\n    encryptedAmount: ethers.utils.hexlify(decoded[2]),\n    inputProof: ethers.utils.hexlify(decoded[3]),\n  };\n}\n\n/**\n * Encodes ERC-7984 `finalizeUnwrap(requestId, cleartextAmount, decryptionProof)` calldata.\n *\n * Calldata is sent to the confidential wrapper to complete unshield phase-2 after\n * the Zama oracle returns a cleartext amount and decryption proof for the unwrap\n * request created in phase-1.\n *\n * Does not set gasLimit — WP owns gas.\n *\n * @param requestId         bytes32 unwrap request id (0x-prefixed)\n * @param cleartextAmount   Decrypted confidential amount (uint64 domain); must be > 0\n * @param decryptionProof   Oracle decryption proof bytes (0x-prefixed)\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n * @throws {Error} if requestId, amount, or proof is invalid\n */\nexport function buildFinalizeUnwrapCalldata(\n  requestId: string,\n  cleartextAmount: string | number | bigint,\n  decryptionProof: string\n): string {\n  if (!ethers.utils.isHexString(requestId) || ethers.utils.hexDataLength(requestId) !== 32) {\n    throw new Error(`buildFinalizeUnwrapCalldata: requestId must be a 32-byte hex string, got '${requestId}'`);\n  }\n\n  let amountBn: bigint;\n  try {\n    amountBn = typeof cleartextAmount === 'bigint' ? cleartextAmount : BigInt(cleartextAmount);\n  } catch {\n    throw new Error(`buildFinalizeUnwrapCalldata: invalid cleartextAmount '${cleartextAmount}'`);\n  }\n  if (amountBn <= 0n) {\n    throw new Error('buildFinalizeUnwrapCalldata: cleartextAmount must be > 0');\n  }\n  if (amountBn > UINT64_MAX) {\n    throw new Error('buildFinalizeUnwrapCalldata: cleartextAmount exceeds uint64');\n  }\n\n  if (!ethers.utils.isHexString(decryptionProof) || ethers.utils.hexDataLength(decryptionProof) === 0) {\n    throw new Error(\n      `buildFinalizeUnwrapCalldata: decryptionProof must be a non-empty hex string, got '${decryptionProof}'`\n    );\n  }\n\n  const method = EthereumAbi.methodID('finalizeUnwrap', [...finalizeUnwrapTypes]);\n  const args = EthereumAbi.rawEncode(\n    [...finalizeUnwrapTypes],\n    [toBuffer(requestId), amountBn.toString(), toBuffer(decryptionProof)]\n  );\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Decodes ERC-7984 `finalizeUnwrap(requestId, cleartextAmount, decryptionProof)` calldata.\n *\n * @param data ABI-encoded finalizeUnwrap calldata (0x-prefixed)\n */\nexport function decodeFinalizeUnwrapCalldata(data: string): {\n  requestId: string;\n  cleartextAmount: string;\n  decryptionProof: string;\n} {\n  if (!data.toLowerCase().startsWith(finalizeUnwrapMethodId.toLowerCase())) {\n    throw new Error(\n      `decodeFinalizeUnwrapCalldata: expected finalizeUnwrap selector ${finalizeUnwrapMethodId}, got ${data.slice(\n        0,\n        10\n      )}`\n    );\n  }\n  const abiCoder = new ethers.utils.AbiCoder();\n  const decoded = abiCoder.decode([...finalizeUnwrapTypes], '0x' + data.slice(10));\n  return {\n    requestId: ethers.utils.hexlify(decoded[0]),\n    cleartextAmount: decoded[1].toString(),\n    decryptionProof: ethers.utils.hexlify(decoded[2]),\n  };\n}\n\n/**\n * Encodes a single ACL.delegateForUserDecryption() call.\n *\n * Grants `delegateAddress` the right to decrypt ERC-7984 token balances on\n * behalf of the calling address (msg.sender) for the specified token contract.\n *\n * @param delegateAddress       BitGo enterprise viewing key address\n * @param tokenContractAddress  ERC-7984 token contract address\n * @param expiryTimestamp       Unix seconds; recommended: Math.floor(Date.now()/1000) + 365*86400\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n */\nexport function buildDelegationCalldata(\n  delegateAddress: string,\n  tokenContractAddress: string,\n  expiryTimestamp: number\n): string {\n  const method = EthereumAbi.methodID('delegateForUserDecryption', [...delegateForUserDecryptionTypes]);\n  const args = EthereumAbi.rawEncode(\n    [...delegateForUserDecryptionTypes],\n    [delegateAddress, tokenContractAddress, expiryTimestamp]\n  );\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Encodes N delegateForUserDecryption calls batched inside ACL.multicall().\n *\n * Produces a single TX that grants delegation for all specified token contracts.\n * Requires tokenContractAddresses.length >= 1.\n * Note: DecryptionDelegationBuilder always uses this function (even for a single token)\n * to keep the transaction shape consistent regardless of token count.\n *\n * @param delegateAddress          BitGo enterprise viewing key address\n * @param tokenContractAddresses   Array of ERC-7984 token contract addresses\n * @param expiryTimestamp          Unix seconds\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n */\nexport function buildMulticallDelegationCalldata(\n  delegateAddress: string,\n  tokenContractAddresses: string[],\n  expiryTimestamp: number\n): string {\n  if (tokenContractAddresses.length === 0) {\n    throw new Error('buildMulticallDelegationCalldata: tokenContractAddresses must not be empty');\n  }\n\n  // Build each inner delegateForUserDecryption call as raw bytes\n  const innerCalls: Buffer[] = tokenContractAddresses.map((tokenAddress) => {\n    const innerMethod = EthereumAbi.methodID('delegateForUserDecryption', [...delegateForUserDecryptionTypes]);\n    const innerArgs = EthereumAbi.rawEncode(\n      [...delegateForUserDecryptionTypes],\n      [delegateAddress, tokenAddress, expiryTimestamp]\n    );\n    return Buffer.concat([innerMethod, innerArgs]);\n  });\n\n  // Encode outer multicall(bytes[])\n  // ethereumjs-abi v0.6.x has a bug where it omits the per-element offset table\n  // for bytes[], producing malformed calldata that on-chain ABI decoders reject.\n  // Use ethers AbiCoder which correctly emits the head offset words.\n  const outerMethod = EthereumAbi.methodID('multicall', [...aclMulticallTypes]);\n  const outerArgs = Buffer.from(\n    new ethers.utils.AbiCoder().encode([...aclMulticallTypes], [innerCalls]).slice(2),\n    'hex'\n  );\n  return addHexPrefix(Buffer.concat([outerMethod, outerArgs]).toString('hex'));\n}\n\n/**\n * Wraps calldata in a ForwarderV4.callFromParent(target, 0, data) call.\n *\n * Used when a forwarder contract must be msg.sender for an external contract\n * call — for example, when the forwarder itself needs to call\n * ACL.delegateForUserDecryption() so that its own balance can be decrypted.\n *\n * Only the parentAddress (root wallet) is allowed to call callFromParent\n * (enforced by the forwarder's onlyParent modifier).\n *\n * @param targetAddress  Address of the contract the forwarder will call (e.g. ACL)\n * @param calldata       ABI-encoded inner calldata (e.g. from buildDelegationCalldata)\n * @returns ABI-encoded callFromParent calldata hex string (0x-prefixed)\n */\nexport function wrapInCallFromParent(targetAddress: string, calldata: string): string {\n  const method = EthereumAbi.methodID('callFromParent', [...callFromParentTypes]);\n  const args = EthereumAbi.rawEncode(\n    [...callFromParentTypes],\n    [\n      targetAddress,\n      0, // value: no ETH transfer\n      toBuffer(calldata), // inner calldata as bytes\n    ]\n  );\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Decodes token contract addresses from delegation calldata.\n *\n * Handles two shapes of calldata:\n *   - Direct ACL.multicall(bytes[]) (root wallet path)\n *   - ForwarderV4.callFromParent(address, uint256, bytes) wrapping a multicall (forwarder path)\n *\n * @param calldata  ABI-encoded delegation calldata (0x-prefixed or raw hex)\n * @returns Array of token contract addresses (lowercase) found in the delegation calls\n * @throws {Error} if the calldata does not start with a recognised method selector\n */\nexport function decodeTokenAddressesFromDelegationCalldata(calldata: string): string[] {\n  const data = calldata.startsWith('0x') ? calldata : '0x' + calldata;\n  const methodId = data.slice(0, 10);\n  const abiCoder = new ethers.utils.AbiCoder();\n\n  let multicallHex: string;\n\n  if (methodId === callFromParentMethodId) {\n    // Decode callFromParent(address, uint256, bytes) — inner bytes is the full multicall calldata.\n    // ethers v5 returns `bytes` as a hex string; use hexlify to normalise to a 0x-prefixed hex string\n    // regardless of whether the runtime returns a string or a Uint8Array.\n    const decoded = abiCoder.decode([...callFromParentTypes], '0x' + data.slice(10));\n    multicallHex = ethers.utils.hexlify(decoded[2]);\n  } else if (methodId === aclMulticallMethodId) {\n    multicallHex = data;\n  } else {\n    throw new Error('Not a valid delegation calldata');\n  }\n\n  if (multicallHex.slice(0, 10) !== aclMulticallMethodId) {\n    throw new Error('Not a valid delegation calldata');\n  }\n\n  // Decode multicall(bytes[]) — each element is an inner delegateForUserDecryption call.\n  // ethers v5 returns bytes[] elements as hex strings; use hexlify to normalise each element.\n  const decoded = abiCoder.decode(['bytes[]'], '0x' + multicallHex.slice(10));\n  const innerCalls: unknown[] = decoded[0];\n\n  const tokenAddresses: string[] = [];\n  for (const innerCall of innerCalls) {\n    const innerHex = ethers.utils.hexlify(innerCall as ethers.utils.BytesLike).slice(2); // strip 0x\n    const innerMethodId = '0x' + innerHex.slice(0, 8);\n    if (innerMethodId !== delegateForUserDecryptionMethodId) {\n      continue;\n    }\n    // Decode delegateForUserDecryption(address delegate, address tokenAddress, uint64 expiry)\n    const innerDecoded = abiCoder.decode([...delegateForUserDecryptionTypes], '0x' + innerHex.slice(8));\n    tokenAddresses.push((innerDecoded[1] as string).toLowerCase());\n  }\n\n  return tokenAddresses;\n}\n\n/**\n * Encodes confidentialTransfer(address to, bytes32 encryptedHandle) calldata.\n * Uses the no-proof variant (selector 0x5bebed7e) — valid when the caller (forwarder)\n * is already ACL-allowed on the handle from when it received the tokens.\n *\n * @param toAddress       Address that will receive the tokens\n * @param encryptedHandle bytes32 encrypted balance handle from confidentialBalanceOf\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n */\nexport function buildConfidentialTransferByHandleCalldata(toAddress: string, encryptedHandle: string): string {\n  const method = Buffer.from(confidentialTransferNoProofMethodId.slice(2), 'hex');\n  const handleBuffer = toBuffer(encryptedHandle);\n  const args = EthereumAbi.rawEncode([...confidentialTransferNoProofTypes], [toAddress, handleBuffer]);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Encodes the full flush calldata for ERC-7984 forwarder consolidation:\n *   callFromParent(tokenContractAddress, 0, confidentialTransfer(parentAddress, encryptedHandle))\n * The forwarder executes the inner confidentialTransfer with msg.sender = forwarder.\n *\n * @param tokenContractAddress  ERC-7984 token contract address\n * @param parentAddress         Root wallet address (destination of flushed tokens)\n * @param encryptedHandle       bytes32 encrypted balance handle from confidentialBalanceOf\n * @returns ABI-encoded calldata hex string (0x-prefixed)\n */\nexport function buildFlushERC7984ForwarderTokenCalldata(\n  tokenContractAddress: string,\n  parentAddress: string,\n  encryptedHandle: string\n): string {\n  const innerCalldata = buildConfidentialTransferByHandleCalldata(parentAddress, encryptedHandle);\n  return wrapInCallFromParent(tokenContractAddress, innerCalldata);\n}\n\n/**\n * Decodes a FlushERC7984ForwarderToken calldata.\n * Strips the outer callFromParent wrapper and the inner confidentialTransfer.\n * Returns { tokenContractAddress, parentAddress, encryptedHandle }.\n *\n * @param data  ABI-encoded flush calldata (0x-prefixed)\n * @returns Decoded fields\n */\nexport function decodeFlushERC7984ForwarderTokenCalldata(data: string): {\n  tokenContractAddress: string;\n  parentAddress: string;\n  encryptedHandle: string;\n} {\n  if (!data.startsWith(callFromParentMethodId)) {\n    throw new Error(\n      `Invalid FlushERC7984ForwarderToken calldata: expected callFromParent selector, got ${data.slice(0, 10)}`\n    );\n  }\n\n  const abiCoder = new ethers.utils.AbiCoder();\n  const outerDecoded = abiCoder.decode([...callFromParentTypes], '0x' + data.slice(10));\n  const tokenContractAddress: string = outerDecoded[0];\n  const innerCalldata: string = ethers.utils.hexlify(outerDecoded[2]);\n\n  if (!innerCalldata.startsWith(confidentialTransferNoProofMethodId)) {\n    throw new Error(\n      `Invalid FlushERC7984ForwarderToken inner calldata: expected confidentialTransfer selector, got ${innerCalldata.slice(\n        0,\n        10\n      )}`\n    );\n  }\n\n  const innerDecoded = abiCoder.decode([...confidentialTransferNoProofTypes], '0x' + innerCalldata.slice(10));\n  const parentAddress: string = innerDecoded[0];\n  const encryptedHandle: string = bufferToHex(toBuffer(innerDecoded[1]));\n\n  return {\n    tokenContractAddress,\n    parentAddress,\n    encryptedHandle,\n  };\n}\n"]}

package/dist/test/unit/transactionBuilder/finalizeUnwrapERC7984.d.ts

@@ -0,0 +1,3 @@
+import { TransactionBuilder } from '../../../src';
+export declare function runFinalizeUnwrapERC7984Tests(coinName: string, getBuilder: (coin: string) => TransactionBuilder): void;
+//# sourceMappingURL=finalizeUnwrapERC7984.d.ts.map

package/dist/test/unit/transactionBuilder/finalizeUnwrapERC7984.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalizeUnwrapERC7984.d.ts","sourceRoot":"","sources":["../../../../test/unit/transactionBuilder/finalizeUnwrapERC7984.ts"],"names":[],"mappings":"AAKA,OAAO,EAAsB,kBAAkB,EAAE,MAAM,cAAc,CAAC;AActE,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,kBAAkB,GAC/C,IAAI,CA6HN"}