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

package/src/settlement/contracts/SettlementSmartContract.ts

@@ -3,40 +3,36 @@ import {
   RollupMerkleTree,
   TypedClass,
   mapSequential,
+  ChildVerificationKeyService,
 } from "@proto-kit/common";
 import {
   AccountUpdate,
   Bool,
   Field,
   method,
-  Mina,
-  Poseidon,
-  Proof,
-  Provable,
   PublicKey,
   Signature,
   SmartContract,
   State,
   state,
-  TokenId,
   UInt32,
-  UInt64,
-  TokenContract,
   AccountUpdateForest,
+  TokenContractV2,
+  PrivateKey,
+  VerificationKey,
+  Permissions,
+  Struct,
+  Provable,
+  TokenId,
+  DynamicProof,
 } from "o1js";
 
 import { NetworkState } from "../../model/network/NetworkState";
-import { Path } from "../../model/Path";
 import { BlockHashMerkleTree } from "../../prover/block/accummulators/BlockHashMerkleTree";
 import {
   BlockProverPublicInput,
   BlockProverPublicOutput,
 } from "../../prover/block/BlockProvable";
-import {
-  OUTGOING_MESSAGE_BATCH_SIZE,
-  OutgoingMessageArgumentBatch,
-} from "../messages/OutgoingMessageArgument";
-import { Withdrawal } from "../messages/Withdrawal";
 import {
   ProvableSettlementHook,
   SettlementHookInputs,
@@ -44,10 +40,13 @@ import {
 } from "../modularity/ProvableSettlementHook";
 
 import { DispatchContractType } from "./DispatchSmartContract";
+import { BridgeContractType } from "./BridgeContract";
+import { TokenBridgeDeploymentAuth } from "./authorizations/TokenBridgeDeploymentAuth";
+import { UpdateMessagesHashAuth } from "./authorizations/UpdateMessagesHashAuth";
 
 /* eslint-disable @typescript-eslint/lines-between-class-members */
 
-export class LazyBlockProof extends Proof<
+export class DynamicBlockProof extends DynamicProof<
   BlockProverPublicInput,
   BlockProverPublicOutput
 > {
@@ -55,18 +54,26 @@ export class LazyBlockProof extends Proof<
 
   public static publicOutputType = BlockProverPublicOutput;
 
-  public static tag: () => { name: string } = () => {
-    throw new Error("Tag not initialized yet");
-  };
+  public static maxProofsVerified = 2 as const;
 }
 
+export class TokenMapping extends Struct({
+  tokenId: Field,
+  publicKey: PublicKey,
+}) {}
+
 export interface SettlementContractType {
+  authorizationField: State<Field>;
+
   initialize: (
     sequencer: PublicKey,
-    dispatchContract: PublicKey
+    dispatchContract: PublicKey,
+    bridgeContract: PublicKey,
+    contractKey: PrivateKey
   ) => Promise<void>;
+  assertStateRoot: (root: Field) => AccountUpdate;
   settle: (
-    blockProof: LazyBlockProof,
+    blockProof: DynamicBlockProof,
     signature: Signature,
     dispatchContractAddress: PublicKey,
     publicKey: PublicKey,
@@ -74,45 +81,174 @@ export interface SettlementContractType {
     outputNetworkState: NetworkState,
     newPromisedMessagesHash: Field
   ) => Promise<void>;
-  rollupOutgoingMessages: (
-    batch: OutgoingMessageArgumentBatch
+  addTokenBridge: (
+    tokenId: Field,
+    address: PublicKey,
+    dispatchContract: PublicKey
   ) => Promise<void>;
-  redeem: (additionUpdate: AccountUpdate) => Promise<void>;
 }
 
 // Some random prefix for the sequencer signature
 export const BATCH_SIGNATURE_PREFIX = prefixToField("pk-batchSignature");
 
-export class SettlementSmartContract
-  extends TokenContract
-  implements SettlementContractType
-{
+// @singleton()
+// export class SettlementSmartContractStaticArgs {
+//   public args?: {
+//     DispatchContract: TypedClass<DispatchContractType & SmartContract>;
+//     hooks: ProvableSettlementHook<unknown>[];
+//     escapeHatchSlotsInterval: number;
+//     BridgeContract: TypedClass<BridgeContractType> & typeof SmartContract;
+//     // Lazily initialized
+//     BridgeContractVerificationKey: VerificationKey | undefined;
+//     BridgeContractPermissions: Permissions | undefined;
+//     signedSettlements: boolean | undefined;
+//   };
+// }
+
+export abstract class SettlementSmartContractBase extends TokenContractV2 {
   // This pattern of injecting args into a smartcontract is currently the only
   // viable solution that works given the inheritance issues of o1js
+  // public static args = container.resolve(SettlementSmartContractStaticArgs);
   public static args: {
     DispatchContract: TypedClass<DispatchContractType & SmartContract>;
     hooks: ProvableSettlementHook<unknown>[];
-    withdrawalStatePath: [string, string];
     escapeHatchSlotsInterval: number;
+    BridgeContract: TypedClass<BridgeContractType> & typeof SmartContract;
+    // Lazily initialized
+    BridgeContractVerificationKey: VerificationKey | undefined;
+    BridgeContractPermissions: Permissions | undefined;
+    signedSettlements: boolean | undefined;
+    ChildVerificationKeyService: ChildVerificationKeyService;
   };
 
-  @state(Field) public sequencerKey = State<Field>();
-  @state(UInt32) public lastSettlementL1BlockHeight = State<UInt32>();
+  events = {
+    "token-bridge-deployed": TokenMapping,
+  };
 
-  @state(Field) public stateRoot = State<Field>();
-  @state(Field) public networkStateHash = State<Field>();
-  @state(Field) public blockHashRoot = State<Field>();
+  abstract sequencerKey: State<Field>;
+  abstract lastSettlementL1BlockHeight: State<UInt32>;
+  abstract stateRoot: State<Field>;
+  abstract networkStateHash: State<Field>;
+  abstract blockHashRoot: State<Field>;
+  abstract dispatchContractAddressX: State<Field>;
 
-  @state(Field) public dispatchContractAddressX = State<Field>();
+  abstract authorizationField: State<Field>;
 
-  @state(Field) public outgoingMessageCursor = State<Field>();
+  // Not @state
+  // abstract offchainStateCommitmentsHash: State<Field>;
 
-  @method async approveBase(forest: AccountUpdateForest) {
-    this.checkZeroBalanceChange(forest);
+  public assertStateRoot(root: Field): AccountUpdate {
+    this.stateRoot.requireEquals(root);
+    return this.self;
   }
 
-  @method
-  public async initialize(sequencer: PublicKey, dispatchContract: PublicKey) {
+  // TODO Like these properties, I am too lazy to properly infer the types here
+  private assertLazyConfigsInitialized() {
+    const uninitializedProperties: string[] = [];
+    const { args } = SettlementSmartContractBase;
+    if (args.BridgeContractPermissions === undefined) {
+      uninitializedProperties.push("BridgeContractPermissions");
+    }
+    if (args.signedSettlements === undefined) {
+      uninitializedProperties.push("signedSettlements");
+    }
+    if (uninitializedProperties.length > 0) {
+      throw new Error(
+        `Lazy configs of SettlementSmartContract haven't been initialized ${uninitializedProperties.reduce(
+          (a, b) => `${a},${b}`
+        )}`
+      );
+    }
+  }
+
+  protected async deployTokenBridge(
+    tokenId: Field,
+    address: PublicKey,
+    dispatchContractAddress: PublicKey,
+    dispatchContractPreconditionEnforced = false
+  ) {
+    Provable.asProver(() => {
+      this.assertLazyConfigsInitialized();
+    });
+
+    const { args } = SettlementSmartContractBase;
+    const BridgeContractClass = args.BridgeContract;
+    const bridgeContract = new BridgeContractClass(address, tokenId);
+
+    const {
+      BridgeContractVerificationKey,
+      signedSettlements,
+      BridgeContractPermissions,
+    } = args;
+
+    if (
+      signedSettlements === undefined ||
+      BridgeContractPermissions === undefined
+    ) {
+      throw new Error(
+        "Static arguments for SettlementSmartContract not initialized"
+      );
+    }
+
+    if (
+      BridgeContractVerificationKey !== undefined &&
+      !BridgeContractVerificationKey.hash.isConstant()
+    ) {
+      throw new Error("Bridge contract verification key has to be constants");
+    }
+
+    // This function is not a zkapps method, therefore it will be part of this methods execution
+    // The returning account update (owner.self) is therefore part of this circuit and is assertable
+    const deploymentAccountUpdate = await bridgeContract.deployProvable(
+      args.BridgeContractVerificationKey,
+      args.signedSettlements!,
+      args.BridgeContractPermissions!,
+      this.address
+    );
+
+    this.approve(deploymentAccountUpdate);
+
+    this.self.body.mayUseToken = {
+      // Only set this if we deploy a custom token
+      parentsOwnToken: tokenId.equals(TokenId.default).not(),
+      inheritFromParent: Bool(false),
+    };
+
+    this.emitEvent(
+      "token-bridge-deployed",
+      new TokenMapping({
+        tokenId: tokenId,
+        publicKey: address,
+      })
+    );
+
+    // We can't set a precondition twice, for the $mina bridge deployment that
+    // would be the case, so we disable it in this case
+    if (!dispatchContractPreconditionEnforced) {
+      this.dispatchContractAddressX.requireEquals(dispatchContractAddress.x);
+    }
+
+    // Set authorization for the auth callback, that we need
+    this.authorizationField.set(
+      new TokenBridgeDeploymentAuth({
+        target: dispatchContractAddress,
+        tokenId,
+        address,
+      }).hash()
+    );
+    const dispatchContract =
+      new SettlementSmartContractBase.args.DispatchContract(
+        dispatchContractAddress
+      );
+    await dispatchContract.enableTokenDeposits(tokenId, address, this.address);
+  }
+
+  protected async initializeBase(
+    sequencer: PublicKey,
+    dispatchContract: PublicKey,
+    bridgeContract: PublicKey,
+    contractKey: PrivateKey
+  ) {
     this.sequencerKey.getAndRequireEquals().assertEquals(Field(0));
     this.stateRoot.getAndRequireEquals().assertEquals(Field(0));
     this.blockHashRoot.getAndRequireEquals().assertEquals(Field(0));
@@ -125,14 +261,23 @@ export class SettlementSmartContract
     this.networkStateHash.set(NetworkState.empty().hash());
     this.dispatchContractAddressX.set(dispatchContract.x);
 
-    const { DispatchContract } = SettlementSmartContract.args;
+    const { DispatchContract } = SettlementSmartContractBase.args;
     const contractInstance = new DispatchContract(dispatchContract);
     await contractInstance.initialize(this.address);
+
+    // Deploy bridge contract for $Mina
+    await this.deployTokenBridge(
+      this.tokenId,
+      bridgeContract,
+      dispatchContract,
+      true
+    );
+
+    contractKey.toPublicKey().assertEquals(this.address);
   }
 
-  @method
-  public async settle(
-    blockProof: LazyBlockProof,
+  protected async settleBase(
+    blockProof: DynamicBlockProof,
     signature: Signature,
     dispatchContractAddress: PublicKey,
     publicKey: PublicKey,
@@ -140,8 +285,17 @@ export class SettlementSmartContract
     outputNetworkState: NetworkState,
     newPromisedMessagesHash: Field
   ) {
+    // Brought in as a constant
+    const blockProofVk =
+      SettlementSmartContractBase.args.ChildVerificationKeyService.getVerificationKey(
+        "BlockProver"
+      );
+    if (!blockProofVk.hash.isConstant()) {
+      throw new Error("Sanity check - vk hash has to be constant");
+    }
+
     // Verify the blockproof
-    blockProof.verify();
+    blockProof.verify(blockProofVk);
 
     // Get and assert on-chain values
     const stateRoot = this.stateRoot.getAndRequireEquals();
@@ -159,7 +313,7 @@ export class SettlementSmartContract
     );
 
     const { DispatchContract, escapeHatchSlotsInterval, hooks } =
-      SettlementSmartContract.args;
+      SettlementSmartContractBase.args;
 
     // Get dispatch contract values
     // These values are witnesses but will be checked later on the AU
@@ -253,6 +407,15 @@ export class SettlementSmartContract
       "Promised messages not honored"
     );
 
+    // Set authorization for the dispatchContract to verify the messages hash update
+    this.authorizationField.set(
+      new UpdateMessagesHashAuth({
+        target: dispatchContract.address,
+        executedMessagesHash: promisedMessagesHash,
+        newPromisedMessagesHash,
+      }).hash()
+    );
+
     // Call DispatchContract
     // This call checks that the promisedMessagesHash, which is already proven
     // to be the blockProofs publicoutput, is actually the current on-chain
@@ -265,79 +428,70 @@ export class SettlementSmartContract
 
     this.lastSettlementL1BlockHeight.set(minBlockHeightIncluded);
   }
+}
 
-  @method
-  public async rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch) {
-    let counter = this.outgoingMessageCursor.getAndRequireEquals();
-    const stateRoot = this.stateRoot.getAndRequireEquals();
+export class SettlementSmartContract
+  extends SettlementSmartContractBase
+  implements SettlementContractType
+{
+  @state(Field) public sequencerKey = State<Field>();
+  @state(UInt32) public lastSettlementL1BlockHeight = State<UInt32>();
 
-    const [withdrawalModule, withdrawalStateName] =
-      SettlementSmartContract.args.withdrawalStatePath;
-    const mapPath = Path.fromProperty(withdrawalModule, withdrawalStateName);
-
-    let accountCreationFeePaid = Field(0);
-
-    for (let i = 0; i < OUTGOING_MESSAGE_BATCH_SIZE; i++) {
-      const args = batch.arguments[i];
-
-      // Check witness
-      const path = Path.fromKey(mapPath, Field, counter);
-
-      args.witness
-        .checkMembership(
-          stateRoot,
-          path,
-          Poseidon.hash(Withdrawal.toFields(args.value))
-        )
-        .assertTrue("Provided Withdrawal witness not valid");
-
-      // Process message
-      const { address, amount } = args.value;
-      const isDummy = address.equals(this.address);
-
-      const tokenAu = this.internal.mint({ address, amount });
-      const isNewAccount = tokenAu.account.isNew.getAndRequireEquals();
-      tokenAu.body.balanceChange.magnitude =
-        tokenAu.body.balanceChange.magnitude.sub(
-          Provable.if(
-            isNewAccount,
-            Mina.getNetworkConstants().accountCreationFee.toConstant(),
-            UInt64.zero
-          )
-        );
-
-      accountCreationFeePaid = accountCreationFeePaid.add(
-        Provable.if(isNewAccount, Field(1e9), Field(0))
-      );
+  @state(Field) public stateRoot = State<Field>();
+  @state(Field) public networkStateHash = State<Field>();
+  @state(Field) public blockHashRoot = State<Field>();
 
-      counter = counter.add(Provable.if(isDummy, Field(0), Field(1)));
-    }
+  @state(Field) public dispatchContractAddressX = State<Field>();
 
-    this.balance.subInPlace(UInt64.Unsafe.fromField(accountCreationFeePaid));
+  @state(Field) public authorizationField = State<Field>();
 
-    this.outgoingMessageCursor.set(counter);
+  @method async approveBase(forest: AccountUpdateForest) {
+    this.checkZeroBalanceChange(forest);
   }
 
   @method
-  public async redeem(additionUpdate: AccountUpdate) {
-    additionUpdate.body.tokenId.assertEquals(
-      TokenId.default,
-      "Tokenid not default token"
+  public async initialize(
+    sequencer: PublicKey,
+    dispatchContract: PublicKey,
+    bridgeContract: PublicKey,
+    contractKey: PrivateKey
+  ) {
+    await this.initializeBase(
+      sequencer,
+      dispatchContract,
+      bridgeContract,
+      contractKey
     );
-    additionUpdate.body.balanceChange.sgn
-      .isPositive()
-      .assertTrue("Sign not correct");
-    const amount = additionUpdate.body.balanceChange.magnitude;
-
-    // Burn tokens
-    this.internal.burn({
-      address: additionUpdate.publicKey,
-      amount,
-    });
+  }
+
+  @method
+  public async addTokenBridge(
+    tokenId: Field,
+    address: PublicKey,
+    dispatchContract: PublicKey
+  ) {
+    await this.deployTokenBridge(tokenId, address, dispatchContract);
+  }
 
-    // Send mina
-    this.approve(additionUpdate);
-    this.balance.subInPlace(amount);
+  @method
+  public async settle(
+    blockProof: DynamicBlockProof,
+    signature: Signature,
+    dispatchContractAddress: PublicKey,
+    publicKey: PublicKey,
+    inputNetworkState: NetworkState,
+    outputNetworkState: NetworkState,
+    newPromisedMessagesHash: Field
+  ) {
+    return await this.settleBase(
+      blockProof,
+      signature,
+      dispatchContractAddress,
+      publicKey,
+      inputNetworkState,
+      outputNetworkState,
+      newPromisedMessagesHash
+    );
   }
 }
 

package/src/settlement/contracts/TokenBridgeTree.ts

@@ -0,0 +1,73 @@
+import {
+  createMerkleTree,
+  InMemoryMerkleTreeStorage,
+  log,
+} from "@proto-kit/common";
+import { Field, Poseidon, PublicKey, SmartContract, Struct } from "o1js";
+
+/**
+ * Merkle tree that contains all the deployed token bridges as a mapping of
+ * tokenId => PublicKey
+ *
+ * It should be used as an append-only tree with incremental indizes - this allows
+ * us to reduce the height of it
+ */
+export class TokenBridgeTree extends createMerkleTree(256) {
+  public indizes: Record<string, bigint> = {};
+
+  /**
+   * Initializes and fills the tree based on all on-chain events that have been
+   * emitted by every emit
+   */
+  public static async buildTreeFromEvents(
+    contract: SmartContract & {
+      events: { "token-bridge-added": typeof TokenBridgeTreeAddition };
+    }
+  ) {
+    const events = await contract.fetchEvents();
+
+    log.debug(`Found ${events.length} token bridge add events`);
+
+    const tree = new TokenBridgeTree(new InMemoryMerkleTreeStorage());
+    const indizes: Record<string, bigint> = {};
+
+    events.forEach(({ type, event }) => {
+      if (type === "token-bridge-added") {
+        const addition =
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          event.data as unknown as TokenBridgeTreeAddition;
+
+        tree.setLeaf(addition.index.toBigInt(), addition.value.hash());
+
+        indizes[addition.value.tokenId.toString()] = addition.index.toBigInt();
+      }
+    });
+    tree.indizes = indizes;
+    return tree;
+  }
+
+  public getIndex(tokenId: Field): bigint {
+    return this.indizes[tokenId.toString()];
+  }
+}
+
+export class TokenBridgeTreeWitness extends TokenBridgeTree.WITNESS {}
+
+export class TokenBridgeEntry extends Struct({
+  address: PublicKey,
+  tokenId: Field,
+}) {
+  public hash() {
+    return Poseidon.hash(TokenBridgeEntry.toFields(this));
+  }
+}
+
+export class TokenBridgeAttestation extends Struct({
+  witness: TokenBridgeTreeWitness,
+  index: Field,
+}) {}
+
+export class TokenBridgeTreeAddition extends Struct({
+  index: Field,
+  value: TokenBridgeEntry,
+}) {}

package/src/settlement/contracts/authorizations/ContractAuthorization.ts

@@ -0,0 +1,11 @@
+import { Field, PublicKey } from "o1js";
+
+/**
+ * Interface for cross-contract call authorization
+ * See https://github.com/proto-kit/framework/issues/202#issuecomment-2407263173
+ */
+export interface ContractAuthorization {
+  target: PublicKey;
+
+  hash: () => Field;
+}

package/src/settlement/contracts/authorizations/TokenBridgeDeploymentAuth.ts

@@ -0,0 +1,16 @@
+import { Field, Poseidon, PublicKey, Struct } from "o1js";
+
+import { ContractAuthorization } from "./ContractAuthorization";
+
+export class TokenBridgeDeploymentAuth
+  extends Struct({
+    target: PublicKey,
+    tokenId: Field,
+    address: PublicKey,
+  })
+  implements ContractAuthorization
+{
+  public hash() {
+    return Poseidon.hash(TokenBridgeDeploymentAuth.toFields(this));
+  }
+}

package/src/settlement/contracts/authorizations/UpdateMessagesHashAuth.ts

@@ -0,0 +1,16 @@
+import { Field, Poseidon, PublicKey, Struct } from "o1js";
+
+import { ContractAuthorization } from "./ContractAuthorization";
+
+export class UpdateMessagesHashAuth
+  extends Struct({
+    target: PublicKey,
+    executedMessagesHash: Field,
+    newPromisedMessagesHash: Field,
+  })
+  implements ContractAuthorization
+{
+  public hash() {
+    return Poseidon.hash(UpdateMessagesHashAuth.toFields(this));
+  }
+}

package/src/settlement/messages/Deposit.ts

@@ -1,6 +1,7 @@
-import { PublicKey, Struct, UInt64 } from "o1js";
+import { Field, PublicKey, Struct, UInt64 } from "o1js";
 
 export class Deposit extends Struct({
+  tokenId: Field,
   address: PublicKey,
   amount: UInt64,
 }) {}

package/src/settlement/messages/Withdrawal.ts

@@ -1,12 +1,14 @@
-import { PublicKey, Struct, UInt64 } from "o1js";
+import { Field, PublicKey, Struct, UInt64 } from "o1js";
 import { EMPTY_PUBLICKEY } from "@proto-kit/common";
 
 export class Withdrawal extends Struct({
+  tokenId: Field,
   address: PublicKey,
   amount: UInt64,
 }) {
   public static dummy() {
     return new Withdrawal({
+      tokenId: Field(0),
       address: EMPTY_PUBLICKEY,
       amount: UInt64.from(0),
     });

package/src/settlement/modularity/ProvableSettlementHook.ts

@@ -1,9 +1,12 @@
 import { Field, PublicKey, UInt32 } from "o1js";
+import { InferProofBase } from "@proto-kit/common";
 
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { NetworkState } from "../../model/network/NetworkState";
 import type { BlockProof } from "../../prover/block/BlockProver";
-import type { SettlementSmartContract } from "../contracts/SettlementSmartContract";
+import type { SettlementSmartContractBase } from "../contracts/SettlementSmartContract";
+
+export type InputBlockProof = InferProofBase<BlockProof>;
 
 export type SettlementStateRecord = {
   sequencerKey: PublicKey;
@@ -15,7 +18,7 @@ export type SettlementStateRecord = {
 };
 
 export type SettlementHookInputs = {
-  blockProof: BlockProof;
+  blockProof: InputBlockProof;
   fromNetworkState: NetworkState;
   toNetworkState: NetworkState;
   newPromisedMessagesHash: Field;
@@ -27,7 +30,7 @@ export abstract class ProvableSettlementHook<
   Config,
 > extends ProtocolModule<Config> {
   public abstract beforeSettlement(
-    smartContract: SettlementSmartContract,
+    smartContract: SettlementSmartContractBase,
     inputs: SettlementHookInputs
   ): Promise<void>;
 }