type ProofType = {
  /** The leaf value being proven for inclusion */
  readonly value: Uint8Array;

  /** Array of sibling hashes forming the Merkle branch */
  readonly proof: readonly Uint8Array[];
};

type ProofLike = ProofType | {
  value: Uint8Array;
  proof: readonly Uint8Array[];
};

import * as Proof from './primitives/Proof/index.js';

const proof = Proof.from({
  value: new Uint8Array([0x01, 0x02, 0x03]),
  proof: [
    new Uint8Array(32), // sibling hash 1
    new Uint8Array(32), // sibling hash 2
  ],
});

const isEqual = Proof.equals(proof1, proof2);

        Root Hash
       /         \
    Hash01      Hash23
   /    \      /    \
Hash0 Hash1 Hash2 Hash3
  |     |     |     |
Leaf0 Leaf1 Leaf2 Leaf3

import * as Hash from './primitives/Hash/index.js';

function verifyProof(
  proof: ProofType,
  expectedRoot: Uint8Array,
  index: number
): boolean {
  let current = Hash.keccak256(proof.value);

  for (const sibling of proof.proof) {
    if (index % 2 === 0) {
      current = Hash.keccak256(concat(current, sibling));
    } else {
      current = Hash.keccak256(concat(sibling, current));
    }
    index = Math.floor(index / 2);
  }

  return equals(current, expectedRoot);
}