prividium 0.18.0 → 0.19.0

package/dist/sdk/create-prividium-client.js

@@ -1,5 +1,5 @@
 import { createClient, publicActions } from 'viem';
-import { selectiveDisclosureActions } from './selective-disclosure/actions';
+import { selectiveDisclosureActions } from './selective-disclosure/actions.js';
 function prividiumActions(client) {
     return {
         call: (args) => {

package/dist/sdk/selective-disclosure/account-properties.d.ts

@@ -1,5 +1,5 @@
 import { type Address, type Hex, type PublicClient } from 'viem';
-import type { AccountDataDisclosureResult, AccountProperties } from './disclosure-result';
+import type { AccountDataDisclosureResult, AccountProperties } from './disclosure-result.js';
 export declare function encodeAccountProperties(params: AccountProperties): Hex;
 /**
  * Compute the internal bytecode hash: blake2s(code || padding || artifacts)

package/dist/sdk/selective-disclosure/account-properties.js

@@ -1,9 +1,9 @@
 import { bytesToHex, hexToBigInt, hexToBytes, keccak256, pad } from 'viem';
-import { encodeBatchInfo } from './batch-info';
-import { computeStateCommitment } from './state-commitment';
-import { blake2s256 } from './utils';
-import { calculateStateMerkleRoot } from './verifiy-proofs';
-import { DIAMOND_ABI } from './verify-disclosure';
+import { encodeBatchInfo } from './batch-info.js';
+import { computeStateCommitment } from './state-commitment.js';
+import { blake2s256 } from './utils.js';
+import { calculateStateMerkleRoot } from './verifiy-proofs.js';
+import { DIAMOND_ABI } from './verify-disclosure.js';
 const PUSH1 = 0x60;
 const PUSH32 = 0x7f;
 const JUMPDEST = 0x5b;

package/dist/sdk/selective-disclosure/actions.d.ts

@@ -1,5 +1,5 @@
 import { type Account, type Address, type BlockTag, type Chain, type Client, type Hex, type RpcSchema, type Transport } from 'viem';
-import type { AccountDataDisclosureResult, EthCallDisclosureResult } from './disclosure-result';
+import type { AccountDataDisclosureResult, EthCallDisclosureResult } from './disclosure-result.js';
 export type DisclosureBlockNumber = number | bigint | Hex | BlockTag;
 export type SelectiveDisclosureActions = {
     tokenSupplyDisclosure: (tokenAddress: Address, blockNumber: DisclosureBlockNumber) => Promise<EthCallDisclosureResult>;

package/dist/sdk/selective-disclosure/disclosure-result.d.ts

@@ -1,5 +1,5 @@
 import type { Address, Hex } from 'viem';
-import type { StorageSlotProof } from './verifiy-proofs';
+import type { StorageSlotProof } from './verifiy-proofs.js';
 export type StateCommitmentPreimage = {
     nextFreeSlot: Hex;
     blockNumber: Hex;
@@ -28,6 +28,8 @@ export type AccountStorageProofs = {
  */
 export type EthCallDisclosureResult = {
     result: Hex;
+    from: Address;
+    to: Address;
     callData: Hex;
     batchNumber: number;
     stateCommitmentPreimage: StateCommitmentPreimage;

package/dist/sdk/selective-disclosure/index.d.ts

@@ -1,7 +1,7 @@
-export * from './account-properties';
-export * from './actions';
-export * from './batch-info';
-export * from './disclosure-result';
-export * from './state-commitment';
-export * from './verifiy-proofs';
-export * from './verify-disclosure';
+export * from './account-properties.js';
+export * from './actions.js';
+export * from './batch-info.js';
+export * from './disclosure-result.js';
+export * from './state-commitment.js';
+export * from './verifiy-proofs.js';
+export * from './verify-disclosure.js';

package/dist/sdk/selective-disclosure/index.js

@@ -1,7 +1,7 @@
-export * from './account-properties';
-export * from './actions';
-export * from './batch-info';
-export * from './disclosure-result';
-export * from './state-commitment';
-export * from './verifiy-proofs';
-export * from './verify-disclosure';
+export * from './account-properties.js';
+export * from './actions.js';
+export * from './batch-info.js';
+export * from './disclosure-result.js';
+export * from './state-commitment.js';
+export * from './verifiy-proofs.js';
+export * from './verify-disclosure.js';

package/dist/sdk/selective-disclosure/state-commitment.js

@@ -1,5 +1,5 @@
 import { bytesToHex, hexToBytes } from 'viem';
-import { blake2s256, concatBytes } from './utils';
+import { blake2s256, concatBytes } from './utils.js';
 export function computeStateCommitment(treeRoot, nextFreeSlot, blockNumber, last256BlockHashesBlake, lastBlockTimestamp) {
     const nextFreeSlotBytes = new Uint8Array(8);
     new DataView(nextFreeSlotBytes.buffer).setBigUint64(0, nextFreeSlot, false); // big-endian

package/dist/sdk/selective-disclosure/verifiy-proofs.js

@@ -1,5 +1,5 @@
 import { bytesToHex, hexToBytes, pad } from 'viem';
-import { blake2s256, concatBytes } from './utils';
+import { blake2s256, concatBytes } from './utils.js';
 function deriveFlatKey(address, storageKey) {
     // blake2s(pad32(address) || storageKey)
     const addressBytes = hexToBytes(pad(address));

package/dist/sdk/selective-disclosure/verify-disclosure.d.ts

@@ -1,5 +1,5 @@
 import { type Address, type Hex, type PublicClient } from 'viem';
-import type { EthCallDisclosureResult } from './disclosure-result';
+import type { EthCallDisclosureResult } from './disclosure-result.js';
 export declare const DIAMOND_ABI: {
     readonly name: "storedBatchHash";
     readonly type: "function";

package/dist/sdk/selective-disclosure/verify-disclosure.js

@@ -1,10 +1,36 @@
 import { keccak256, pad, parseAbiItem } from 'viem';
-import { encodeBatchInfo } from './batch-info';
-import { computeStateCommitment } from './state-commitment';
-import { calculateStateMerkleRoot } from './verifiy-proofs';
+import { encodeBatchInfo } from './batch-info.js';
+import { computeStateCommitment } from './state-commitment.js';
+import { calculateStateMerkleRoot } from './verifiy-proofs.js';
 export const DIAMOND_ABI = [
     parseAbiItem('function storedBatchHash(uint256 _batchNumber) external view returns (bytes32)')
 ];
+const tracerStr = `{
+    prevTop: null,
+    state: {
+        reads: {},success: null, value: null
+    },
+    step: function (log, _db) {
+        if (log.op.toString() === 'SLOAD') {
+            const addr = log.contract.getAddress();
+            const slot = this.prevTop;
+            if (!this.state.reads[addr]) this.state.reads[addr] = [];
+            if (this.state.reads[addr].indexOf(slot) === -1) this.state.reads[addr].push(slot);
+        }
+        
+        if (log.stack.length() > 0) {
+            this.prevTop = log.stack.peek(0).toString(16);
+        } else {
+            this.prevTop = null;
+        }
+    },
+    fault: (_log, _db) => {},
+    result: function (ctx, _db) {
+        this.state.success = ctx.error === null;
+        this.state.value = ctx.output.toString('hex');
+        return this.state;
+    }
+}`;
 /**
  * Verifies an ethCall disclosure response end-to-end.
  *
@@ -60,31 +86,51 @@ export async function verifyEthCallDisclosure(disclosure, l1Client, l2Client, di
     if (batchInfoHash !== storedBatchHash) {
         return false;
     }
-    // Step 5: Replay the call on L2 with state overrides to verify the proven
-    // storage values produce the expected result.
-    const contractAddress = disclosure.proofs[0].address;
-    const stateOverride = disclosure.proofs.map((proof) => {
+    const contractAddress = disclosure.to;
+    const stateOverride = {};
+    for (const proof of disclosure.proofs) {
         const address = proof.address.toLowerCase();
         const code = contractBytecodes[address];
         if (!code) {
             throw new Error(`Missing bytecode for contract ${address}`);
         }
-        return {
-            address,
+        const state = {};
+        for (const sp of proof.storageProofs) {
+            state[sp.key] = sp.proof.type === 'existing' ? sp.proof.value : pad('0x0');
+        }
+        stateOverride[address] = {
             code,
-            state: proof.storageProofs.map((sp) => ({
-                slot: sp.key,
-                value: sp.proof.type === 'existing' ? sp.proof.value : pad('0x0')
-            }))
+            state: state
         };
+    }
+    const debugResult = await l2Client.request({
+        method: 'debug_traceCall',
+        params: [
+            {
+                from: disclosure.from,
+                to: contractAddress,
+                data: disclosure.callData
+            },
+            'latest',
+            {
+                tracer: tracerStr,
+                stateOverrides: stateOverride
+            }
+        ]
     });
-    const callResult = await l2Client.call({
-        to: contractAddress,
-        data: disclosure.callData,
-        stateOverride
-    });
-    if (!callResult.data) {
+    if (!debugResult.success) {
         return false;
     }
-    return BigInt(callResult.data) === BigInt(disclosure.result);
+    for (const address in debugResult.reads) {
+        for (const slot of debugResult.reads[address]) {
+            const realSlot = `0x${slot}`;
+            const exists = disclosure.proofs.find((p) => p.address.toLowerCase() === address.toLowerCase() &&
+                p.storageProofs.some((sp) => BigInt(sp.key) === BigInt(realSlot)));
+            if (!exists) {
+                return false;
+            }
+        }
+    }
+    const callResult = debugResult.value;
+    return BigInt(callResult) === BigInt(disclosure.result);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prividium",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "type": "module",
   "bin": {
     "prividium": "bin/cli.js"