@aztec/foundation 0.55.1 → 0.56.0

package/dest/trees/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trees/index.ts"],"names":[],"mappings":";AAAA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAC;IACnB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC;IACjB;;OAEG;IACH,MAAM,IAAI,eAAe,CAAC;IAC1B;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAC;IACnB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAC/D,UAAU,IAAI,MAAM,CAAC;IACrB;;OAEG;IACH,YAAY,IAAI,MAAM,CAAC;CACxB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trees/index.ts"],"names":[],"mappings":";AAAA,cAAc,6BAA6B,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAC;IACnB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC;IACjB;;OAEG;IACH,MAAM,IAAI,eAAe,CAAC;IAC1B;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAC;IACnB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAC/D,UAAU,IAAI,MAAM,CAAC;IACrB;;OAEG;IACH,YAAY,IAAI,MAAM,CAAC;CACxB"}

package/dest/trees/index.js

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9
+export * from './unbalanced_merkle_root.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQyJ9

package/dest/trees/unbalanced_merkle_root.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+import { sha256Trunc } from '@aztec/foundation/crypto';
+/**
+ * Computes the merkle root for an unbalanced tree.
+ *
+ * @dev Adapted from proving-state.ts -> findMergeLevel and unbalanced_tree.ts.
+ * Calculates the tree upwards layer by layer until we reach the root.
+ * The L1 calculation instead computes the tree from right to left (slightly cheaper gas).
+ * TODO: A more thorough investigation of which method is cheaper, then use that method everywhere.
+ */
+export declare function computeUnbalancedMerkleRoot(leaves: Buffer[], emptyLeaf?: Buffer, hasher?: typeof sha256Trunc): Buffer;
+//# sourceMappingURL=unbalanced_merkle_root.d.ts.map

package/dest/trees/unbalanced_merkle_root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalanced_merkle_root.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_root.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,qBAAc,GAAG,MAAM,CAwC9G"}

package/dest/trees/unbalanced_merkle_root.js

@@ -0,0 +1,52 @@
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { sha256Trunc } from '@aztec/foundation/crypto';
+/**
+ * Computes the merkle root for an unbalanced tree.
+ *
+ * @dev Adapted from proving-state.ts -> findMergeLevel and unbalanced_tree.ts.
+ * Calculates the tree upwards layer by layer until we reach the root.
+ * The L1 calculation instead computes the tree from right to left (slightly cheaper gas).
+ * TODO: A more thorough investigation of which method is cheaper, then use that method everywhere.
+ */
+export function computeUnbalancedMerkleRoot(leaves, emptyLeaf, hasher = sha256Trunc) {
+    // Pad leaves to 2
+    if (leaves.length < 2) {
+        if (emptyLeaf === undefined) {
+            throw new Error('Cannot compute a Merkle root with less than 2 leaves');
+        }
+        else {
+            leaves = padArrayEnd(leaves, emptyLeaf, 2);
+        }
+    }
+    const depth = Math.ceil(Math.log2(leaves.length));
+    let [layerWidth, nodeToShift] = leaves.length & 1 ? [leaves.length - 1, leaves[leaves.length - 1]] : [leaves.length, Buffer.alloc(0)];
+    // Allocate this layer's leaves and init the next layer up
+    let thisLayer = leaves.slice(0, layerWidth);
+    let nextLayer = [];
+    for (let i = 0; i < depth; i++) {
+        for (let j = 0; j < layerWidth; j += 2) {
+            // Store the hash of each pair one layer up
+            nextLayer[j / 2] = hasher(Buffer.concat([thisLayer[j], thisLayer[j + 1]]));
+        }
+        layerWidth /= 2;
+        if (layerWidth & 1) {
+            if (nodeToShift.length) {
+                // If the next layer has odd length, and we have a node that needs to be shifted up, add it here
+                nextLayer.push(nodeToShift);
+                layerWidth += 1;
+                nodeToShift = Buffer.alloc(0);
+            }
+            else {
+                // If we don't have a node waiting to be shifted, store the next layer's final node to be shifted
+                layerWidth -= 1;
+                nodeToShift = nextLayer[layerWidth];
+            }
+        }
+        // reset the layers
+        thisLayer = nextLayer;
+        nextLayer = [];
+    }
+    // return the root
+    return thisLayer[0];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/foundation",
-  "version": "0.55.1",
+  "version": "0.56.0",
   "packageManager": "yarn@3.4.1",
   "type": "module",
   "main": "./dest/index.js",
@@ -17,6 +17,7 @@
     "./crypto": "./dest/crypto/index.js",
     "./error": "./dest/error/index.js",
     "./eth-address": "./dest/eth-address/index.js",
+    "./eth-signature": "./dest/eth-signature/index.js",
     "./queue": "./dest/queue/index.js",
     "./fs": "./dest/fs/index.js",
     "./buffer": "./dest/buffer/index.js",
@@ -90,7 +91,7 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.55.1",
+    "@aztec/bb.js": "0.56.0",
     "@koa/cors": "^5.0.0",
     "@noble/curves": "^1.2.0",
     "bn.js": "^5.2.1",
@@ -144,7 +145,8 @@
     "prettier": "^2.7.1",
     "supertest": "^6.3.3",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.0.4",
+    "viem": "^2.7.15"
   },
   "files": [
     "dest",

package/src/abi/decoder.ts

@@ -6,21 +6,21 @@ import { isAztecAddressStruct } from './utils.js';
 /**
  * The type of our decoded ABI.
  */
-export type DecodedReturn = bigint | boolean | AztecAddress | DecodedReturn[] | { [key: string]: DecodedReturn };
+export type AbiDecoded = bigint | boolean | AztecAddress | AbiDecoded[] | { [key: string]: AbiDecoded };
 
 /**
- * Decodes return values from a function call.
- * Missing support for integer and string.
+ * Decodes values using a provided ABI.
+ * Missing support for signed integer.
  */
-class ReturnValuesDecoder {
-  constructor(private returnTypes: AbiType[], private flattened: Fr[]) {}
+class AbiDecoder {
+  constructor(private types: AbiType[], private flattened: Fr[]) {}
 
   /**
    * Decodes a single return value from field to the given type.
    * @param abiType - The type of the return value.
    * @returns The decoded return value.
    */
-  private decodeReturn(abiType: AbiType): DecodedReturn {
+  private decodeNext(abiType: AbiType): AbiDecoded {
     switch (abiType.kind) {
       case 'field':
         return this.getNextField().toBigInt();
@@ -34,18 +34,18 @@ class ReturnValuesDecoder {
       case 'array': {
         const array = [];
         for (let i = 0; i < abiType.length; i += 1) {
-          array.push(this.decodeReturn(abiType.type));
+          array.push(this.decodeNext(abiType.type));
         }
         return array;
       }
       case 'struct': {
-        const struct: { [key: string]: DecodedReturn } = {};
+        const struct: { [key: string]: AbiDecoded } = {};
         if (isAztecAddressStruct(abiType)) {
           return new AztecAddress(this.getNextField().toBuffer());
         }
 
         for (const field of abiType.fields) {
-          struct[field.name] = this.decodeReturn(field.type);
+          struct[field.name] = this.decodeNext(field.type);
         }
         return struct;
       }
@@ -59,7 +59,7 @@ class ReturnValuesDecoder {
       case 'tuple': {
         const array = [];
         for (const tupleAbiType of abiType.fields) {
-          array.push(this.decodeReturn(tupleAbiType));
+          array.push(this.decodeNext(tupleAbiType));
         }
         return array;
       }
@@ -69,8 +69,8 @@ class ReturnValuesDecoder {
   }
 
   /**
-   * Gets the next field in the flattened return values.
-   * @returns The next field in the flattened return values.
+   * Gets the next field in the flattened buffer.
+   * @returns The next field in the flattened buffer.
    */
   private getNextField(): Fr {
     const field = this.flattened.shift();
@@ -81,30 +81,29 @@ class ReturnValuesDecoder {
   }
 
   /**
-   * Decodes all the return values for the given function ABI.
-   * Aztec.nr support only single return value
-   * The return value can however be simple types, structs or arrays
+   * Decodes all the values for the given ABI.
+   * The decided value can be simple types, structs or arrays
    * @returns The decoded return values.
    */
-  public decode(): DecodedReturn {
-    if (this.returnTypes.length > 1) {
-      throw new Error('Multiple return values not supported');
+  public decode(): AbiDecoded {
+    if (this.types.length > 1) {
+      throw new Error('Multiple types not supported');
     }
-    if (this.returnTypes.length === 0) {
+    if (this.types.length === 0) {
       return [];
     }
-    return this.decodeReturn(this.returnTypes[0]);
+    return this.decodeNext(this.types[0]);
   }
 }
 
 /**
- * Decodes return values from a function call.
- * @param abi - The ABI entry of the function.
- * @param returnValues - The decoded return values.
+ * Decodes values in a flattened Field array using a provided ABI.
+ * @param abi - The ABI to use as reference.
+ * @param buffer - The flattened Field array to decode.
  * @returns
  */
-export function decodeReturnValues(returnTypes: AbiType[], returnValues: Fr[]) {
-  return new ReturnValuesDecoder(returnTypes, returnValues.slice()).decode();
+export function decodeFromAbi(typ: AbiType[], buffer: Fr[]) {
+  return new AbiDecoder(typ, buffer.slice()).decode();
 }
 
 /**

package/src/buffer/buffer32.ts

@@ -112,7 +112,25 @@ export class Buffer32 {
    * @param str - The TX hash in string format.
    * @returns A new Buffer32 object.
    */
+  public static fromStringUnchecked(str: string): Buffer32 {
+    return new Buffer32(Buffer.from(str, 'hex'));
+  }
+
+  /**
+   * Converts a string into a Buffer32 object.
+   * NOTE: this method includes checks for the 0x prefix and the length of the string.
+   *       if you dont need this checks, use fromStringUnchecked instead.
+   *
+   * @param str - The TX hash in string format.
+   * @returns A new Buffer32 object.
+   */
   public static fromString(str: string): Buffer32 {
+    if (str.startsWith('0x')) {
+      str = str.slice(2);
+    }
+    if (str.length !== 64) {
+      throw new Error(`Expected string to be 64 characters long, but was ${str.length}`);
+    }
     return new Buffer32(Buffer.from(str, 'hex'));
   }
 

package/src/config/env_var.ts

@@ -1,6 +1,6 @@
 export type EnvVar =
   | 'AZTEC_PORT'
-  | 'ASSUME_PROVEN_UNTIL_BLOCK_NUMBER'
+  | 'ASSUME_PROVEN_THROUGH_BLOCK_NUMBER'
   | 'TEST_ACCOUNTS'
   | 'ENABLE_GAS'
   | 'API_PREFIX'

package/src/crypto/index.ts

@@ -6,6 +6,7 @@ export * from './sha256/index.js';
 export * from './sha512/index.js';
 export * from './pedersen/index.js';
 export * from './poseidon/index.js';
+export * from './secp256k1-signer/index.js';
 
 /**
  * Init the bb singleton. This constructs (if not already) the barretenberg sync api within bb.js itself.

package/src/crypto/secp256k1-signer/index.ts

@@ -0,0 +1,2 @@
+export * from './secp256k1_signer.js';
+export * from './utils.js';

package/src/crypto/secp256k1-signer/secp256k1_signer.ts

@@ -0,0 +1,38 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { type EthAddress } from '@aztec/foundation/eth-address';
+import { type Signature } from '@aztec/foundation/eth-signature';
+
+import { addressFromPrivateKey, makeEthSignDigest, signMessage } from './utils.js';
+
+/**
+ * Secp256k1Signer
+ *
+ * A class for signing messages using a secp256k1 private key.
+ * - This is a slim drop in replacement for an Ethereum signer, so it can be used in the same way.
+ * - See `utils.ts` for functions that enable recovering addresses and public keys from signatures.
+ */
+export class Secp256k1Signer {
+  public readonly address: EthAddress;
+
+  constructor(private privateKey: Buffer32) {
+    this.address = addressFromPrivateKey(privateKey.buffer);
+  }
+
+  sign(message: Buffer32): Signature {
+    return signMessage(message, this.privateKey.buffer);
+  }
+
+  /**
+   * Sign a message using the same method as eth_sign
+   * @param message - The message to sign.
+   * @returns The signature.
+   */
+  signMessage(message: Buffer32): Signature {
+    const digest = makeEthSignDigest(message);
+    return this.sign(digest);
+  }
+
+  static random(): Secp256k1Signer {
+    return new Secp256k1Signer(Buffer32.random());
+  }
+}

package/src/crypto/secp256k1-signer/utils.ts

@@ -0,0 +1,99 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+
+import { Buffer32 } from '../../buffer/buffer32.js';
+import { EthAddress } from '../../eth-address/index.js';
+import { Signature } from '../../eth-signature/eth_signature.js';
+import { keccak256 } from '../keccak/index.js';
+
+const ETH_SIGN_PREFIX = '\x19Ethereum Signed Message:\n32';
+
+// We just hash the message to make it easier to work with in the smart contract.
+export function makeEthSignDigest(message: Buffer32): Buffer32 {
+  const prefix = Buffer.from(ETH_SIGN_PREFIX);
+  return Buffer32.fromBuffer(keccak256(Buffer.concat([prefix, message.buffer])));
+}
+
+/**
+ * Converts a public key to an address.
+ * @param publicKey - The public key to convert.
+ * @returns The address.
+ */
+function publicKeyToAddress(publicKey: Buffer): EthAddress {
+  const hash = keccak256(publicKey.subarray(1));
+  return new EthAddress(hash.subarray(12));
+}
+
+/**
+ * Converts a private key to a public key.
+ * @param privateKey - The private key to convert.
+ * @returns The public key.
+ */
+export function publicKeyFromPrivateKey(privateKey: Buffer): Buffer {
+  return Buffer.from(secp256k1.getPublicKey(privateKey, false));
+}
+
+/**
+ * Converts a private key to an address.
+ * @param privateKey - The private key to convert.
+ * @returns The address.
+ */
+export function addressFromPrivateKey(privateKey: Buffer): EthAddress {
+  const publicKey = publicKeyFromPrivateKey(privateKey);
+  return publicKeyToAddress(publicKey);
+}
+
+/**
+ * Recovers an address from a hash and a signature.
+ * @param hash - The hash to recover the address from.
+ * @param signature - The signature to recover the address from.
+ * @returns The address.
+ */
+export function recoverAddress(hash: Buffer32, signature: Signature): EthAddress {
+  const publicKey = recoverPublicKey(hash, signature);
+  return publicKeyToAddress(publicKey);
+}
+
+/**
+ * @attribution - viem
+ * Converts a yParityOrV value to a recovery bit.
+ * @param yParityOrV - The yParityOrV value to convert.
+ * @returns The recovery bit.
+ */
+function toRecoveryBit(yParityOrV: number) {
+  if (yParityOrV === 0 || yParityOrV === 1) {
+    return yParityOrV;
+  }
+  if (yParityOrV === 27) {
+    return 0;
+  }
+  if (yParityOrV === 28) {
+    return 1;
+  }
+  throw new Error('Invalid yParityOrV value');
+}
+
+/**
+ * Signs a message using ecdsa over the secp256k1 curve.
+ * @param message - The message to sign.
+ * @param privateKey - The private key to sign the message with.
+ * @returns The signature.
+ */
+export function signMessage(message: Buffer32, privateKey: Buffer) {
+  const { r, s, recovery } = secp256k1.sign(message.buffer, privateKey);
+  return new Signature(Buffer32.fromBigInt(r), Buffer32.fromBigInt(s), recovery ? 28 : 27);
+}
+
+/**
+ * Recovers a public key from a hash and a signature.
+ * @param hash - The hash to recover the public key from.
+ * @param signature - The signature to recover the public key from.
+ * @returns The public key.
+ */
+export function recoverPublicKey(hash: Buffer32, signature: Signature): Buffer {
+  const { r, s, v } = signature;
+  const recoveryBit = toRecoveryBit(v);
+  const sig = new secp256k1.Signature(r.toBigInt(), s.toBigInt()).addRecoveryBit(recoveryBit);
+
+  const publicKey = sig.recoverPublicKey(hash.buffer).toHex(false);
+  return Buffer.from(publicKey, 'hex');
+}

package/src/crypto/sha256/index.ts

@@ -1,14 +1,147 @@
+/* eslint-disable camelcase */
 import { default as hash } from 'hash.js';
 
 import { Fr } from '../../fields/fields.js';
 import { truncateAndPad } from '../../serialize/free_funcs.js';
 import { type Bufferable, serializeToBuffer } from '../../serialize/serialize.js';
 
-export const sha256 = (data: Buffer) => Buffer.from(hash.sha256().update(data).digest());
+export function sha256(data: Buffer) {
+  return Buffer.from(hash.sha256().update(data).digest());
+}
 
-export const sha256Trunc = (data: Buffer) => truncateAndPad(sha256(data));
+export function sha256Trunc(data: Buffer) {
+  return truncateAndPad(sha256(data));
+}
 
-export const sha256ToField = (data: Bufferable[]) => {
+export function sha256ToField(data: Bufferable[]) {
   const buffer = serializeToBuffer(data);
   return Fr.fromBuffer(sha256Trunc(buffer));
-};
+}
+
+/**
+ * The "SHA256 Compression" operation (component operation of SHA256 "Hash").
+ * WARNING: modifies `state` in place (and also returns it)
+ *
+ * This algorithm is extracted from the hash.js package
+ * and modified to take in an initial state to operate on.
+ *
+ * @param state - The initial state to operate on (modified in-place). 8 u32s.
+ * @param inputs - The inputs to compress into the state. 16 u32s.
+ * @returns The modified state. 8 u32s.
+ */
+export function sha256Compression(state: Uint32Array, inputs: Uint32Array): Uint32Array {
+  if (state.length !== 8) {
+    throw new Error('`state` argument to SHA256 compression must be of length 8');
+  }
+  if (inputs.length !== 16) {
+    throw new Error('`inputs` argument to SHA256 compression must be of length 16');
+  }
+
+  const W = new Array(64);
+  const k = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98,
+    0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8,
+    0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
+    0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
+    0xc67178f2,
+  ];
+  let i = 0;
+  for (i = 0; i < 16; i++) {
+    W[i] = inputs[i];
+  }
+  for (i = 16; i < W.length; i++) {
+    W[i] = sum32_4(
+      W[i - 16],
+      W[i - 7],
+      g0_256(W[i - 15]), // Rot17, Rot18, Sh3
+      g1_256(W[i - 2]), //ROt17, Rot19, Sh10
+    );
+  }
+
+  let a = state[0];
+  let b = state[1];
+  let c = state[2];
+  let d = state[3];
+  let e = state[4];
+  let f = state[5];
+  let g = state[6];
+  let h = state[7];
+
+  for (let i = 0; i < 64; i++) {
+    const T1 = sum32_5(
+      h,
+      s1_256(e), // Rot6, Rot11, Rot25
+      ch32(e, f, g),
+      k[i],
+      W[i],
+    );
+
+    const T2 = sum32(
+      s0_256(a), // Rot2, Rot13, Rot22
+      maj32(a, b, c),
+    );
+    h = g;
+    g = f;
+    f = e;
+    e = sum32(d, T1);
+    d = c;
+    c = b;
+    b = a;
+    a = sum32(T1, T2);
+  }
+
+  state[0] = sum32(state[0], a);
+  state[1] = sum32(state[1], b);
+  state[2] = sum32(state[2], c);
+  state[3] = sum32(state[3], d);
+  state[4] = sum32(state[4], e);
+  state[5] = sum32(state[5], f);
+  state[6] = sum32(state[6], g);
+  state[7] = sum32(state[7], h);
+  return state;
+}
+
+// SHA256  HELPER FUNCTIONS (from hash.js package)
+
+function rotr32(w: number, b: number) {
+  return (w >>> b) | (w << (32 - b));
+}
+
+function sum32(a: number, b: number) {
+  return (a + b) >>> 0;
+}
+
+function sum32_4(a: number, b: number, c: number, d: number) {
+  return (a + b + c + d) >>> 0;
+}
+
+function sum32_5(a: number, b: number, c: number, d: number, e: number) {
+  return (a + b + c + d + e) >>> 0;
+}
+
+function ch32(x: number, y: number, z: number) {
+  return (x & y) ^ (~x & z);
+}
+
+function maj32(x: number, y: number, z: number) {
+  return (x & y) ^ (x & z) ^ (y & z);
+}
+
+function s0_256(x: number) {
+  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
+}
+
+function s1_256(x: number) {
+  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
+}
+
+function g0_256(x: number) {
+  return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);
+}
+
+function g1_256(x: number) {
+  return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);
+}

package/src/eth-signature/eth_signature.ts

@@ -0,0 +1,90 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+/**Viem Signature
+ *
+ * A version of the Signature class that uses `0x${string}` values for r and s rather than
+ * Buffer32s
+ */
+export type ViemSignature = {
+  r: `0x${string}`;
+  s: `0x${string}`;
+  v: number;
+  isEmpty: boolean;
+};
+
+/**
+ * Signature
+ *
+ * Contains a signature split into it's primary components (r,s,v)
+ */
+export class Signature {
+  constructor(
+    /** The r value of the signature */
+    public readonly r: Buffer32,
+    /** The s value of the signature */
+    public readonly s: Buffer32,
+    /** The v value of the signature */
+    public readonly v: number,
+    /** Does this struct store an empty signature */
+    public readonly isEmpty: boolean = false,
+  ) {}
+
+  static fromBuffer(buf: Buffer | BufferReader): Signature {
+    const reader = BufferReader.asReader(buf);
+
+    const r = reader.readObject(Buffer32);
+    const s = reader.readObject(Buffer32);
+    const v = reader.readNumber();
+
+    const isEmpty = r.isZero() && s.isZero();
+
+    return new Signature(r, s, v, isEmpty);
+  }
+
+  /**
+   * A seperate method exists for this as when signing locally with viem, as when
+   * parsing from viem, we can expect the v value to be a u8, rather than our
+   * default serialization of u32
+   */
+  static from0xString(sig: `0x${string}`): Signature {
+    const buf = Buffer.from(sig.slice(2), 'hex');
+    const reader = BufferReader.asReader(buf);
+
+    const r = reader.readObject(Buffer32);
+    const s = reader.readObject(Buffer32);
+    const v = reader.readUInt8();
+
+    const isEmpty = r.isZero() && s.isZero();
+
+    return new Signature(r, s, v, isEmpty);
+  }
+
+  static empty(): Signature {
+    return new Signature(Buffer32.ZERO, Buffer32.ZERO, 0, true);
+  }
+
+  equals(other: Signature): boolean {
+    return this.r.equals(other.r) && this.s.equals(other.s) && this.v === other.v && this.isEmpty === other.isEmpty;
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.r, this.s, this.v]);
+  }
+
+  to0xString(): `0x${string}` {
+    return `0x${this.r.toString()}${this.s.toString()}${this.v.toString(16)}`;
+  }
+
+  /**
+   * Return the signature with `0x${string}` encodings for r and s
+   */
+  toViemSignature(): ViemSignature {
+    return {
+      r: this.r.to0xString(),
+      s: this.s.to0xString(),
+      v: this.v,
+      isEmpty: this.isEmpty,
+    };
+  }
+}

package/src/eth-signature/index.ts

@@ -0,0 +1 @@
+export * from './eth_signature.js';

package/src/fields/point.ts

@@ -1,5 +1,6 @@
 import { toBigIntBE } from '../bigint-buffer/index.js';
-import { poseidon2Hash, randomBoolean } from '../crypto/index.js';
+import { poseidon2Hash } from '../crypto/poseidon/index.js';
+import { randomBoolean } from '../crypto/random/index.js';
 import { BufferReader, FieldReader, serializeToBuffer } from '../serialize/index.js';
 import { Fr } from './fields.js';