@triadxyz/triad-protocol 3.3.0-beta → 3.3.2-beta

package/dist/utils/merkle.d.ts

@@ -20,3 +20,16 @@ export declare function createClaimData(data: {
     user: string;
     amount: number;
 }[]): ClaimData[];
+export declare function debugMerkleProof(userPubkey: PublicKey, amount: number, merkleProof: number[][], merkleRoot: number[]): {
+    isValid: boolean;
+    steps: Array<{
+        step: number;
+        currentHash: string;
+        proofElement: string;
+        isCurrentSmaller: boolean;
+        combined: string;
+        newHash: string;
+    }>;
+    finalHash: string;
+    expectedRoot: string;
+};

package/dist/utils/merkle.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClaimData = exports.generateMerkleTree = exports.MerkleTree = void 0;
+exports.debugMerkleProof = exports.createClaimData = exports.generateMerkleTree = exports.MerkleTree = void 0;
 const sha3_1 = require("@noble/hashes/sha3");
 const web3_js_1 = require("@solana/web3.js");
 class MerkleTree {
@@ -30,7 +30,7 @@ class MerkleTree {
             for (let i = 0; i < currentLevel.length; i += 2) {
                 const left = currentLevel[i];
                 const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left;
-                const combined = left.compare(right) <= 0
+                const combined = left.compare(right) < 0
                     ? Buffer.concat([left, right])
                     : Buffer.concat([right, left]);
                 nextLevel.push(Buffer.from((0, sha3_1.keccak_256)(combined)));
@@ -61,6 +61,9 @@ class MerkleTree {
             if (siblingIndex < this.tree[level].length) {
                 proof.push(this.tree[level][siblingIndex]);
             }
+            else {
+                proof.push(this.tree[level][currentIndex]);
+            }
             currentIndex = Math.floor(currentIndex / 2);
         }
         return proof.map((hash) => Array.from(hash));
@@ -85,7 +88,7 @@ class MerkleTree {
         let currentHash = Buffer.from((0, sha3_1.keccak_256)(leafData));
         for (const proofElement of proof) {
             const proofBuffer = Buffer.from(proofElement);
-            const combined = currentHash.compare(proofBuffer) <= 0
+            const combined = currentHash.compare(proofBuffer) < 0
                 ? Buffer.concat([currentHash, proofBuffer])
                 : Buffer.concat([proofBuffer, currentHash]);
             currentHash = Buffer.from((0, sha3_1.keccak_256)(combined));
@@ -110,3 +113,64 @@ function createClaimData(data) {
     }));
 }
 exports.createClaimData = createClaimData;
+function debugMerkleProof(userPubkey, amount, merkleProof, merkleRoot) {
+    console.log('🔍 Debug Merkle Proof Validation (Rust Compatible)');
+    console.log('User:', userPubkey.toBase58());
+    console.log('Amount:', amount);
+    console.log('Proof length:', merkleProof.length);
+    console.log('Max theoretical elements:', Math.pow(2, merkleProof.length));
+    const leafData = Buffer.concat([
+        userPubkey.toBytes(),
+        (() => {
+            const amountBytes = Buffer.alloc(8);
+            const amountLamports = BigInt(Math.floor(amount * Math.pow(10, 6)));
+            amountBytes.writeBigUInt64LE(amountLamports, 0);
+            return amountBytes;
+        })()
+    ]);
+    let currentHash = Buffer.from((0, sha3_1.keccak_256)(leafData));
+    console.log('Initial leaf hash:', currentHash.toString('hex'));
+    const steps = [];
+    for (let i = 0; i < merkleProof.length; i++) {
+        const proofElement = merkleProof[i];
+        const proofBuffer = Buffer.from(proofElement);
+        const isCurrentSmaller = currentHash.compare(proofBuffer) < 0;
+        let combined;
+        if (isCurrentSmaller) {
+            combined = Buffer.concat([currentHash, proofBuffer]);
+        }
+        else {
+            combined = Buffer.concat([proofBuffer, currentHash]);
+        }
+        const newHash = Buffer.from((0, sha3_1.keccak_256)(combined));
+        const step = {
+            step: i + 1,
+            currentHash: currentHash.toString('hex'),
+            proofElement: proofBuffer.toString('hex'),
+            isCurrentSmaller,
+            combined: combined.toString('hex'),
+            newHash: newHash.toString('hex')
+        };
+        steps.push(step);
+        console.log(`Step ${i + 1}:`);
+        console.log(`  Current: ${step.currentHash}`);
+        console.log(`  Proof:   ${step.proofElement}`);
+        console.log(`  Order:   ${isCurrentSmaller ? 'current + proof' : 'proof + current'}`);
+        console.log(`  Result:  ${step.newHash}`);
+        currentHash = newHash;
+    }
+    const rootBuffer = Buffer.from(merkleRoot);
+    const finalHash = currentHash.toString('hex');
+    const expectedRoot = rootBuffer.toString('hex');
+    const isValid = currentHash.equals(rootBuffer);
+    console.log('Final hash:', finalHash);
+    console.log('Expected root:', expectedRoot);
+    console.log('Valid:', isValid);
+    return {
+        isValid,
+        steps,
+        finalHash,
+        expectedRoot
+    };
+}
+exports.debugMerkleProof = debugMerkleProof;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triadxyz/triad-protocol",
-  "version": "3.3.0-beta",
+  "version": "3.3.2-beta",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",