feat: optional encoder arg for standardLeafHash

src/hashes.ts

@@ -4,9 +4,16 @@ import { BytesLike, HexString, concat, compare } from './bytes';
 
 export type LeafHash<T> = (leaf: T) => HexString;
 export type NodeHash = (left: BytesLike, right: BytesLike) => HexString;
+export type Encoder = {
+  encode: (types: string[], values: any[]) => string;
+};
 
-export function standardLeafHash<T extends any[]>(types: string[], value: T): HexString {
-  return keccak256(keccak256(defaultAbiCoder.encode(types, value)));
+export function standardLeafHash<T extends any[]>(
+  types: string[],
+  value: T,
+  encoder: Encoder = defaultAbiCoder,
+): HexString {
+  return keccak256(keccak256(encoder.encode(types, value)));
 }
 
 export function standardNodeHash(a: BytesLike, b: BytesLike): HexString {

src/standard.test.ts

@@ -3,6 +3,7 @@ import { HashZero as zero } from '@ethersproject/constants';
 import { keccak256 } from '@ethersproject/keccak256';
 import { StandardMerkleTree } from './standard';
 import { InvalidArgumentError, InvariantError } from './utils/errors';
+import { defaultAbiCoder } from '@ethersproject/abi';
 
 fc.configureGlobal({ numRuns: process.env.CI ? 5000 : 100 });
 
@@ -149,3 +150,28 @@ test('reject malformed tree dump', t => {
     new InvariantError('Merkle tree is invalid'),
   );
 });
+
+const customEncoderLeaf = fc.tuple(
+  fc.uint8Array({ minLength: 1, maxLength: 1 }),
+  fc.uint8Array({ minLength: 1, maxLength: 1 }),
+);
+const customEncoderLeaves = fc.array(customEncoderLeaf, { minLength: 1, maxLength: 1000 });
+
+testProp('custom encoder', [customEncoderLeaves], (t, customEncoderLeaves) => {
+  const customEncoder = {
+    encode: (types: string[], values: any[]) => {
+      return defaultAbiCoder.encode(types.slice().reverse(), values);
+    },
+  };
+
+  const customEncoderEncoding = ['bytes', 'bytes1'];
+
+  const customEncoderTree = StandardMerkleTree.of(customEncoderLeaves, customEncoderEncoding, {}, customEncoder);
+  const reversedEncodingTree = StandardMerkleTree.of(customEncoderLeaves, customEncoderEncoding.slice().reverse());
+
+  t.deepEqual(customEncoderTree.root, reversedEncodingTree.root);
+
+  const defaultEncodingTree = StandardMerkleTree.of(customEncoderLeaves, customEncoderEncoding);
+
+  t.notDeepEqual(customEncoderTree.root, defaultEncodingTree.root);
+});

src/standard.ts

@@ -1,8 +1,9 @@
+import { defaultAbiCoder } from '@ethersproject/abi';
 import { BytesLike, HexString, toHex } from './bytes';
 import { MultiProof, processProof, processMultiProof } from './core';
 import { MerkleTreeData, MerkleTreeImpl } from './merkletree';
 import { MerkleTreeOptions } from './options';
-import { standardLeafHash } from './hashes';
+import { Encoder, standardLeafHash } from './hashes';
 import { validateArgument } from './utils/errors';
 
 export interface StandardMerkleTreeData<T extends any[]> extends MerkleTreeData<T> {
@@ -15,44 +16,58 @@ export class StandardMerkleTree<T extends any[]> extends MerkleTreeImpl<T> {
     protected readonly tree: HexString[],
     protected readonly values: StandardMerkleTreeData<T>['values'],
     protected readonly leafEncoding: string[],
+    protected readonly encoder: Encoder = defaultAbiCoder,
   ) {
-    super(tree, values, leaf => standardLeafHash(leafEncoding, leaf));
+    super(tree, values, leaf => standardLeafHash(leafEncoding, leaf, encoder));
   }
 
   static of<T extends any[]>(
     values: T[],
     leafEncoding: string[],
     options: MerkleTreeOptions = {},
+    encoder: Encoder = defaultAbiCoder,
   ): StandardMerkleTree<T> {
     // use default nodeHash (standardNodeHash)
-    const [tree, indexedValues] = MerkleTreeImpl.prepare(values, options, leaf => standardLeafHash(leafEncoding, leaf));
-    return new StandardMerkleTree(tree, indexedValues, leafEncoding);
+    const [tree, indexedValues] = MerkleTreeImpl.prepare(values, options, leaf =>
+      standardLeafHash(leafEncoding, leaf, encoder),
+    );
+    return new StandardMerkleTree(tree, indexedValues, leafEncoding, encoder);
   }
 
-  static load<T extends any[]>(data: StandardMerkleTreeData<T>): StandardMerkleTree<T> {
+  static load<T extends any[]>(
+    data: StandardMerkleTreeData<T>,
+    encoder: Encoder = defaultAbiCoder,
+  ): StandardMerkleTree<T> {
     validateArgument(data.format === 'standard-v1', `Unknown format '${data.format}'`);
     validateArgument(data.leafEncoding !== undefined, 'Expected leaf encoding');
 
-    const tree = new StandardMerkleTree(data.tree, data.values, data.leafEncoding);
+    const tree = new StandardMerkleTree(data.tree, data.values, data.leafEncoding, encoder);
     tree.validate();
     return tree;
   }
 
-  static verify<T extends any[]>(root: BytesLike, leafEncoding: string[], leaf: T, proof: BytesLike[]): boolean {
+  static verify<T extends any[]>(
+    root: BytesLike,
+    leafEncoding: string[],
+    leaf: T,
+    proof: BytesLike[],
+    encoder: Encoder = defaultAbiCoder,
+  ): boolean {
     // use default nodeHash (standardNodeHash) for processProof
-    return toHex(root) === processProof(standardLeafHash(leafEncoding, leaf), proof);
+    return toHex(root) === processProof(standardLeafHash(leafEncoding, leaf, encoder), proof);
   }
 
   static verifyMultiProof<T extends any[]>(
     root: BytesLike,
     leafEncoding: string[],
     multiproof: MultiProof<BytesLike, T>,
+    encoder: Encoder = defaultAbiCoder,
   ): boolean {
     // use default nodeHash (standardNodeHash) for processMultiProof
     return (
       toHex(root) ===
       processMultiProof({
-        leaves: multiproof.leaves.map(leaf => standardLeafHash(leafEncoding, leaf)),
+        leaves: multiproof.leaves.map(leaf => standardLeafHash(leafEncoding, leaf, encoder)),
         proof: multiproof.proof,
         proofFlags: multiproof.proofFlags,
       })