@proto-kit/protocol 0.1.1-develop.1088 → 0.1.1-develop.1309

package/src/settlement/contracts/DispatchContractProtocolModule.ts

@@ -1,6 +1,8 @@
 import { inject, injectable } from "tsyringe";
+import { PublicKey } from "o1js";
+import { CompileRegistry } from "@proto-kit/common";
 
-import { RuntimeLike } from "../../model/RuntimeLike";
+import { RuntimeLike, RuntimeMethodIdMapping } from "../../model/RuntimeLike";
 import {
   ContractModule,
   SmartContractClassFromInterface,
@@ -9,6 +11,7 @@ import {
 import {
   DispatchSmartContract,
   DispatchContractType,
+  DispatchSmartContractBase,
 } from "./DispatchSmartContract";
 
 export type DispatchContractConfig = {
@@ -18,22 +21,53 @@ export type DispatchContractConfig = {
 @injectable()
 export class DispatchContractProtocolModule extends ContractModule<
   DispatchContractType,
-  undefined,
   DispatchContractConfig
 > {
   public constructor(@inject("Runtime") private readonly runtime: RuntimeLike) {
     super();
   }
 
+  public eventsDefinition() {
+    return new DispatchSmartContract(PublicKey.empty<typeof PublicKey>())
+      .events;
+  }
+
+  private checkConfigIntegrity(
+    incomingMessagesMethods: Record<string, `${string}.${string}`>,
+    runtimeMethodIds: RuntimeMethodIdMapping
+  ) {
+    const missing = Object.values(incomingMessagesMethods).filter(
+      (method) => runtimeMethodIds[method] === undefined
+    );
+    if (missing.length > 0) {
+      throw new Error(
+        `Incoming messages config references a unknown methods: [${missing}]`
+      );
+    }
+  }
+
   public contractFactory(): SmartContractClassFromInterface<DispatchContractType> {
     const { incomingMessagesMethods } = this.config;
     const methodIdMappings = this.runtime.methodIdResolver.methodIdMap();
 
-    DispatchSmartContract.args = {
+    this.checkConfigIntegrity(incomingMessagesMethods, methodIdMappings);
+
+    DispatchSmartContractBase.args = {
       incomingMessagesPaths: incomingMessagesMethods,
       methodIdMappings,
+      settlementContractClass:
+        DispatchSmartContractBase.args?.settlementContractClass,
     };
 
     return DispatchSmartContract;
   }
+
+  public async compile(registry: CompileRegistry) {
+    if (DispatchSmartContractBase.args.settlementContractClass === undefined) {
+      throw new Error("Reference to Settlement Contract not set");
+    }
+    return {
+      DispatchSmartContract: await registry.compile(DispatchSmartContract),
+    };
+  }
 }

package/src/settlement/contracts/DispatchSmartContract.ts

@@ -1,16 +1,20 @@
 import {
   AccountUpdate,
+  Bool,
   Field,
   method,
   Poseidon,
+  Provable,
   ProvableExtended,
   PublicKey,
   Reducer,
   SmartContract,
   State,
   state,
+  TokenId,
   UInt64,
 } from "o1js";
+import { InMemoryMerkleTreeStorage, TypedClass } from "@proto-kit/common";
 
 import { RuntimeMethodIdMapping } from "../../model/RuntimeLike";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
@@ -20,6 +24,17 @@ import {
 } from "../../utils/MinaPrefixedProvableHashList";
 import { Deposit } from "../messages/Deposit";
 
+import type { SettlementContractType } from "./SettlementSmartContract";
+import { TokenBridgeDeploymentAuth } from "./authorizations/TokenBridgeDeploymentAuth";
+import { UpdateMessagesHashAuth } from "./authorizations/UpdateMessagesHashAuth";
+import {
+  TokenBridgeAttestation,
+  TokenBridgeEntry,
+  TokenBridgeTree,
+  TokenBridgeTreeAddition,
+  TokenBridgeTreeWitness,
+} from "./TokenBridgeTree";
+
 export const ACTIONS_EMPTY_HASH = Reducer.initialActionState;
 
 export interface DispatchContractType {
@@ -28,27 +43,46 @@ export interface DispatchContractType {
     newPromisedMessagesHash: Field
   ) => Promise<void>;
   initialize: (settlementContract: PublicKey) => Promise<void>;
+  enableTokenDeposits: (
+    tokenId: Field,
+    bridgeContractAddress: PublicKey,
+    settlementContractAddress: PublicKey
+  ) => Promise<void>;
 
   promisedMessagesHash: State<Field>;
 }
 
-export class DispatchSmartContract
-  extends SmartContract
-  implements DispatchContractType
-{
+const tokenBridgeRoot = new TokenBridgeTree(
+  new InMemoryMerkleTreeStorage()
+).getRoot();
+
+export abstract class DispatchSmartContractBase extends SmartContract {
   public static args: {
     methodIdMappings: RuntimeMethodIdMapping;
     incomingMessagesPaths: Record<string, `${string}.${string}`>;
+    settlementContractClass?: TypedClass<SettlementContractType> &
+      typeof SmartContract;
   };
 
-  @state(Field) public promisedMessagesHash = State<Field>();
+  events = {
+    "token-bridge-added": TokenBridgeTreeAddition,
+    // We need a placeholder event here, so that o1js internally adds a identifier to the
+    // emitted event-fields. That will lead to the o1js API being able to distinguish the
+    // TokenBridgeEvents from the manually emitted events for the incoming messages
+    "incoming-message-placeholder": Field,
+  };
 
-  @state(Field) public honoredMessagesHash = State<Field>();
+  abstract promisedMessagesHash: State<Field>;
 
-  @state(PublicKey) public settlementContract = State<PublicKey>();
+  abstract honoredMessagesHash: State<Field>;
 
-  @method
-  public async updateMessagesHash(
+  abstract settlementContract: State<PublicKey>;
+
+  abstract tokenBridgeRoot: State<Field>;
+
+  abstract tokenBridgeCount: State<Field>;
+
+  protected updateMessagesHashBase(
     executedMessagesHash: Field,
     newPromisedMessagesHash: Field
   ) {
@@ -63,10 +97,25 @@ export class DispatchSmartContract
     // Assert and apply new promisedMessagesHash
     this.self.account.actionState.requireEquals(newPromisedMessagesHash);
     this.promisedMessagesHash.set(newPromisedMessagesHash);
+
+    const settlementContractAddress =
+      this.settlementContract.getAndRequireEquals();
+    const settlementContract =
+      new DispatchSmartContractBase.args.settlementContractClass!(
+        settlementContractAddress
+      );
+
+    settlementContract.authorizationField.requireEquals(
+      new UpdateMessagesHashAuth({
+        target: this.address,
+        executedMessagesHash,
+        newPromisedMessagesHash,
+      }).hash()
+    );
+    this.approve(settlementContract.self);
   }
 
-  @method
-  public async initialize(settlementContract: PublicKey) {
+  protected initializeBase(settlementContract: PublicKey) {
     this.promisedMessagesHash.getAndRequireEquals().assertEquals(Field(0));
     this.honoredMessagesHash.getAndRequireEquals().assertEquals(Field(0));
     this.settlementContract
@@ -78,7 +127,7 @@ export class DispatchSmartContract
     this.settlementContract.set(settlementContract);
   }
 
-  private dispatchMessage<Type>(
+  protected dispatchMessage<Type>(
     methodId: Field,
     value: Type,
     valueType: ProvableExtended<Type>
@@ -100,37 +149,178 @@ export class DispatchSmartContract
       data: [actionData],
     };
 
-    const eventHash = MinaEvents.eventHash(args);
+    // Find event index of placeholder event that we can use for manual event dispatching
+    const eventIndex = Object.keys(this.events)
+      .sort()
+      .indexOf("incoming-message-placeholder");
+    if (eventIndex === -1) {
+      throw new Error("Unknown event type for placeholder event");
+    }
+    const paddedArgs = [Field(eventIndex), ...args];
+
+    const eventHash = MinaEvents.eventHash(paddedArgs);
     this.self.body.events = {
       hash: eventHash,
-      data: [args],
+      data: [paddedArgs],
     };
   }
 
+  protected async enableTokenDepositsBase(
+    tokenId: Field,
+    bridgeContractAddress: PublicKey,
+    // Witness it here, since o1js doesn't fetch this state correctly since
+    // its updated in a parent AU
+    settlementContractAddress: PublicKey
+    // treeWitness: TokenBridgeTreeWitness
+  ) {
+    this.settlementContract.requireEquals(settlementContractAddress);
+    const settlementContract =
+      new DispatchSmartContractBase.args.settlementContractClass!(
+        settlementContractAddress
+      );
+
+    // Append bridge address to the tree
+    // TODO This not concurrent and will fail if multiple users deploy bridges at the same time
+    const counter = this.tokenBridgeCount.getAndRequireEquals();
+    const root = this.tokenBridgeRoot.getAndRequireEquals();
+
+    const treeWitness = await Provable.witnessAsync(
+      TokenBridgeTreeWitness,
+      async () => {
+        const tree = await TokenBridgeTree.buildTreeFromEvents(this);
+        return tree.getWitness(counter.toBigInt());
+      }
+    );
+
+    Provable.log(root);
+    treeWitness
+      .checkMembership(root, counter, Field(0))
+      .assertTrue("Bridge Tree Witness not valid");
+
+    const entry = new TokenBridgeEntry({
+      tokenId,
+      address: bridgeContractAddress,
+    });
+    const newRoot = treeWitness.calculateRoot(entry.hash());
+    this.tokenBridgeRoot.set(newRoot);
+    this.tokenBridgeCount.set(counter.add(1));
+
+    this.emitEvent(
+      "token-bridge-added",
+      new TokenBridgeTreeAddition({
+        index: counter,
+        value: entry,
+      })
+    );
+
+    // Authenticate call via callback
+    settlementContract.authorizationField.requireEquals(
+      new TokenBridgeDeploymentAuth({
+        target: this.address,
+        tokenId,
+        address: bridgeContractAddress,
+      }).hash()
+    );
+
+    this.approve(settlementContract.self);
+  }
+}
+
+export class DispatchSmartContract
+  extends DispatchSmartContractBase
+  implements DispatchContractType
+{
+  @state(Field) public promisedMessagesHash = State<Field>();
+
+  @state(Field) public honoredMessagesHash = State<Field>();
+
+  @state(PublicKey) public settlementContract = State<PublicKey>();
+
+  @state(Field) public tokenBridgeRoot = State<Field>(tokenBridgeRoot);
+
+  @state(Field) public tokenBridgeCount = State<Field>();
+
+  @method
+  public async enableTokenDeposits(
+    tokenId: Field,
+    bridgeContractAddress: PublicKey,
+    settlementContractAddress: PublicKey
+  ) {
+    await this.enableTokenDepositsBase(
+      tokenId,
+      bridgeContractAddress,
+      settlementContractAddress
+    );
+  }
+
+  @method
+  public async updateMessagesHash(
+    executedMessagesHash: Field,
+    newPromisedMessagesHash: Field
+  ) {
+    return this.updateMessagesHashBase(
+      executedMessagesHash,
+      newPromisedMessagesHash
+    );
+  }
+
+  @method
+  public async initialize(settlementContract: PublicKey) {
+    return this.initializeBase(settlementContract);
+  }
+
   @method
-  public async deposit(amount: UInt64) {
-    // Save this, since otherwise it would be a second witness later,
-    // which could be a different values than the first
-    const sender = this.sender.getUnconstrained();
+  public async deposit(
+    amount: UInt64,
+    tokenId: Field,
+    bridgingContract: PublicKey,
+    bridgingContractAttestation: TokenBridgeAttestation,
+    l2Receiver: PublicKey
+  ) {
+    const childrenMayUseToken: AccountUpdate["body"]["mayUseToken"] = {
+      parentsOwnToken: Bool(false),
+      // MayUseToken has to be set only for custom tokens
+      inheritFromParent: tokenId.equals(TokenId.default).not(),
+    };
 
-    const settlementContract = this.settlementContract.getAndRequireEquals();
+    // Check that the bridgingContract parameter is valid => is in the offchain tree
+    const bridgeTreeRoot = this.tokenBridgeRoot.getAndRequireEquals();
+    const entry = new TokenBridgeEntry({
+      tokenId,
+      address: bridgingContract,
+    });
+
+    bridgingContractAttestation.witness
+      .checkMembership(
+        bridgeTreeRoot,
+        bridgingContractAttestation.index,
+        entry.hash()
+      )
+      .assertTrue("Bridging Contract Attestation not valid");
 
     // Credit the amount to the settlement contract
-    const balanceAU = AccountUpdate.create(settlementContract);
+    const balanceAU = AccountUpdate.create(bridgingContract, tokenId);
     balanceAU.balance.addInPlace(amount);
-    this.self.approve(balanceAU);
+    balanceAU.body.mayUseToken = childrenMayUseToken;
+    this.approve(balanceAU);
 
     const action = new Deposit({
-      address: sender,
+      tokenId,
+      address: l2Receiver,
       amount,
     });
 
     const { methodIdMappings, incomingMessagesPaths } =
-      DispatchSmartContract.args;
+      DispatchSmartContractBase.args;
 
     const methodId = Field(
       methodIdMappings[incomingMessagesPaths.deposit].methodId
     ).toConstant();
     this.dispatchMessage(methodId.toConstant(), action, Deposit);
+
+    this.self.body.mayUseToken = {
+      parentsOwnToken: tokenId.equals(TokenId.default).not(),
+      inheritFromParent: Bool(false),
+    };
   }
 }

package/src/settlement/contracts/SettlementContractProtocolModule.ts

@@ -1,6 +1,10 @@
-import { TypedClass } from "@proto-kit/common";
-import { SmartContract } from "o1js";
 import { inject, injectable, injectAll } from "tsyringe";
+import {
+  ArtifactRecord,
+  ChildVerificationKeyService,
+  CompileRegistry,
+  log,
+} from "@proto-kit/common";
 
 import { BlockProvable } from "../../prover/block/BlockProvable";
 import {
@@ -9,17 +13,18 @@ import {
 } from "../ContractModule";
 import { ProvableSettlementHook } from "../modularity/ProvableSettlementHook";
 
-import { DispatchContractType } from "./DispatchSmartContract";
+import { DispatchSmartContractBase } from "./DispatchSmartContract";
 import {
-  LazyBlockProof,
   SettlementContractType,
   SettlementSmartContract,
+  SettlementSmartContractBase,
 } from "./SettlementSmartContract";
+import { BridgeContractBase } from "./BridgeContract";
+import { DispatchContractProtocolModule } from "./DispatchContractProtocolModule";
+import { BridgeContractProtocolModule } from "./BridgeContractProtocolModule";
 
 export type SettlementContractConfig = {
   escapeHatchSlotsInterval?: number;
-  withdrawalStatePath: `${string}.${string}`;
-  withdrawalMethodPath: `${string}.${string}`;
 };
 
 // 24 hours
@@ -28,40 +33,76 @@ const DEFAULT_ESCAPE_HATCH = (60 / 3) * 24;
 @injectable()
 export class SettlementContractProtocolModule extends ContractModule<
   SettlementContractType,
-  TypedClass<DispatchContractType & SmartContract>,
   SettlementContractConfig
 > {
   public constructor(
     @injectAll("ProvableSettlementHook")
     private readonly hooks: ProvableSettlementHook<unknown>[],
     @inject("BlockProver")
-    private readonly blockProver: BlockProvable
+    private readonly blockProver: BlockProvable,
+    @inject("DispatchContract")
+    private readonly dispatchContractModule: DispatchContractProtocolModule,
+    @inject("BridgeContract")
+    private readonly bridgeContractModule: BridgeContractProtocolModule,
+    private readonly childVerificationKeyService: ChildVerificationKeyService
   ) {
-    LazyBlockProof.tag = blockProver.zkProgrammable.zkProgram[0].Proof.tag;
     super();
   }
 
-  public contractFactory(
-    dispatchContract: TypedClass<DispatchContractType & SmartContract>
-  ): SmartContractClassFromInterface<SettlementContractType> {
+  public contractFactory(): SmartContractClassFromInterface<SettlementContractType> {
     const { hooks, config } = this;
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const withdrawalStatePathSplit = config.withdrawalStatePath.split(".") as [
-      string,
-      string,
-    ];
+    const dispatchContract = this.dispatchContractModule.contractFactory();
+    const bridgeContract = this.bridgeContractModule.contractFactory();
 
     const escapeHatchSlotsInterval =
       config.escapeHatchSlotsInterval ?? DEFAULT_ESCAPE_HATCH;
 
-    SettlementSmartContract.args = {
+    const { args } = SettlementSmartContractBase;
+    SettlementSmartContractBase.args = {
       DispatchContract: dispatchContract,
       hooks,
-      withdrawalStatePath: withdrawalStatePathSplit,
       escapeHatchSlotsInterval,
+      BridgeContract: bridgeContract,
+      BridgeContractVerificationKey: args?.BridgeContractVerificationKey,
+      BridgeContractPermissions: args?.BridgeContractPermissions,
+      signedSettlements: args?.signedSettlements,
+      ChildVerificationKeyService: this.childVerificationKeyService,
     };
 
+    // Ideally we don't want to have this cyclic dependency, but we have it in the protocol,
+    // So its logical that we can't avoid that here
+    BridgeContractBase.args.SettlementContract = SettlementSmartContract;
+
+    DispatchSmartContractBase.args.settlementContractClass =
+      SettlementSmartContract;
+
     return SettlementSmartContract;
   }
+
+  public async compile(
+    registry: CompileRegistry
+  ): Promise<ArtifactRecord | undefined> {
+    // Dependencies
+    const bridgeArtifact = await this.bridgeContractModule.compile(registry);
+
+    await this.blockProver.compile(registry);
+
+    // Init params
+    SettlementSmartContractBase.args.BridgeContractVerificationKey =
+      bridgeArtifact.BridgeContract.verificationKey;
+
+    if (SettlementSmartContractBase.args.signedSettlements === undefined) {
+      throw new Error(
+        "Args not fully initialized - make sure to also include the SettlementModule in the sequencer"
+      );
+    }
+
+    log.debug("Compiling Settlement Contract");
+
+    const artifact = await registry.compile(SettlementSmartContract);
+
+    return {
+      SettlementSmartContract: artifact,
+    };
+  }
 }