Merge pull request #206 from proto-kit/feature/custom-token-bridging

Add support for custom token bridging

Author: maht0rz

.nvmrc

@@ -1 +1 @@
-v18.14.2
+v22.9.0

package-lock.json

@@ -34,7 +34,7 @@
     "@proto-kit/module": "*",
     "@proto-kit/protocol": "*",
     "@proto-kit/sequencer": "*",
-    "o1js": "^1.1.0",
+    "o1js": "^1.6.0",
     "tsyringe": "^4.7.0"
   },
   "devDependencies": {

packages/api/package.json

@@ -23,7 +23,7 @@
     "typescript-memoize": "^1.1.1"
   },
   "peerDependencies": {
-    "o1js": "^1.1.0",
+    "o1js": "^1.6.0",
     "tsyringe": "^4.7.0"
   },
   "devDependencies": {

packages/common/package.json

@@ -0,0 +1,10 @@
+import { Field, VerificationKey } from "o1js";
+
+export function dummyVerificationKey() {
+  return new VerificationKey({
+    hash: Field(
+      "3392518251768960475377392625298437850623664973002200885669375116181514017494"
+    ),
+    data: "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",
+  });
+}

packages/common/src/dummyVerificationKey.ts

@@ -0,0 +1,42 @@
+import { EventsRecord } from "./EventEmittingComponent";
+import { EventEmitter } from "./EventEmitter";
+
+/**
+ * Event Emitter variant that emits a certain event only once to a registered listener.
+ * Additionally, if a listener registers to a event that has already been emitted, it
+ * re-emits it to said listener.
+ * This pattern is especially useful for listening for inclusions of transactions.
+ * Those events will only occur once, and listeners could come too late to the party,
+ * so we need to make sure they get notified as well in those cases.
+ */
+export class ReplayingSingleUseEventEmitter<
+  Events extends EventsRecord,
+> extends EventEmitter<Events> {
+  public emitted: Partial<Events> = {};
+
+  public emit<Key extends keyof Events>(
+    event: Key,
+    ...parameters: Events[Key]
+  ) {
+    super.emit(event, ...parameters);
+    this.emitted[event] = parameters;
+    this.listeners[event] = [];
+  }
+
+  public onAll(listener: (event: keyof Events, args: unknown[]) => void) {
+    Object.entries(this.emitted).forEach(([key, params]) => {
+      if (params !== undefined) listener(key, params);
+    });
+    super.onAll(listener);
+  }
+
+  public on<Key extends keyof Events>(
+    event: Key,
+    listener: (...args: Events[Key]) => void
+  ) {
+    if (this.emitted[event] !== undefined) {
+      listener(...this.emitted[event]!);
+    }
+    super.on(event, listener);
+  }
+}

packages/common/src/events/ReplayingSingleUseEventEmitter.ts

@@ -16,4 +16,5 @@ export * from "./trees/MerkleTreeStore";
 export * from "./trees/InMemoryMerkleTreeStorage";
 export * from "./trees/RollupMerkleTree";
 export * from "./events/EventEmitterProxy";
+export * from "./events/ReplayingSingleUseEventEmitter";
 export * from "./trees/MockAsyncMerkleStore";

packages/common/src/index.ts

@@ -17,6 +17,27 @@ export function requireTrue(
   }
 }
 
+/**
+ * Utility function to split an array of type T into a record <K, T[]> based on a
+ * function T => K that determines the key of each record
+ */
+export function splitArray<T, K extends string | number>(
+  arr: T[],
+  split: (t: T) => K
+): Record<K, T[] | undefined> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  const record = {} as { [Key in K]: T[] };
+  arr.forEach((element) => {
+    const k = split(element);
+    if (record[k] !== undefined) {
+      record[k].push(element);
+    } else {
+      record[k] = [element];
+    }
+  });
+  return record;
+}
+
 export function range(
   startOrEnd: number,
   endOrNothing?: number | undefined
@@ -52,7 +73,7 @@ export function reduceSequential<T, U>(
 export function mapSequential<T, R>(
   array: T[],
   f: (element: T, index: number, array: T[]) => Promise<R>
-) {
+): Promise<R[]> {
   return array.reduce<Promise<R[]>>(async (r, element, index, a) => {
     const ret = await r;
     const next = await f(element, index, a);

packages/common/src/utils.ts

@@ -2,6 +2,7 @@ import { ZkProgram, FlexibleProvablePure, Proof, Field, Provable } from "o1js";
 import { Memoize } from "typescript-memoize";
 
 import { log } from "../log";
+import { dummyVerificationKey } from "../dummyVerificationKey";
 
 import { MOCK_PROOF } from "./provableMethod";
 
@@ -75,10 +76,7 @@ export function verifyToMockable<PublicInput, PublicOutput>(
   };
 }
 
-export const MOCK_VERIFICATION_KEY = {
-  data: "mock-verification-key",
-  hash: Field(0),
-};
+export const MOCK_VERIFICATION_KEY = dummyVerificationKey();
 
 export function compileToMockable(
   compile: Compile,

packages/common/src/zkProgrammable/ZkProgrammable.ts

@@ -15,6 +15,7 @@ export type ArgumentTypes = (
 export type DecoratedMethod = (...args: ArgumentTypes) => Promise<unknown>;
 
 export const MOCK_PROOF = "mock-proof";
+// (await Proof.dummy(Field(0), Field(0), 2)).proof as string;
 
 export function toProver(
   methodName: string,