@proto-kit/protocol 0.1.1-develop.457 → 0.1.1-develop.651

package/src/settlement/contracts/SettlementSmartContract.ts

@@ -0,0 +1,329 @@
+import { prefixToField, RollupMerkleTree, TypedClass } from "@proto-kit/common";
+import {
+  AccountUpdate,
+  Bool,
+  Field,
+  method,
+  Mina,
+  Poseidon,
+  Proof,
+  Provable,
+  PublicKey,
+  Signature,
+  SmartContract,
+  State,
+  state,
+  TokenId,
+  UInt32,
+  UInt64,
+} 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,
+  SettlementStateRecord,
+} from "../modularity/ProvableSettlementHook";
+
+import { DispatchContractType } from "./DispatchSmartContract";
+
+export class LazyBlockProof extends Proof<
+  BlockProverPublicInput,
+  BlockProverPublicOutput
+> {
+  public static publicInputType = BlockProverPublicInput;
+
+  public static publicOutputType = BlockProverPublicOutput;
+
+  public static tag: () => { name: string } = () => {
+    throw new Error("Tag not initialized yet");
+  };
+}
+
+export interface SettlementContractType {
+  initialize: (sequencer: PublicKey, dispatchContract: PublicKey) => void;
+  settle: (
+    blockProof: LazyBlockProof,
+    signature: Signature,
+    dispatchContractAddress: PublicKey,
+    publicKey: PublicKey,
+    inputNetworkState: NetworkState,
+    outputNetworkState: NetworkState,
+    newPromisedMessagesHash: Field
+  ) => void;
+  rollupOutgoingMessages: (batch: OutgoingMessageArgumentBatch) => void;
+  redeem: (additionUpdate: AccountUpdate) => void;
+}
+
+// Some random prefix for the sequencer signature
+export const BATCH_SIGNATURE_PREFIX = prefixToField("pk-batchSignature");
+
+export class SettlementSmartContract
+  extends SmartContract
+  implements SettlementContractType
+{
+  // 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: {
+    DispatchContract: TypedClass<DispatchContractType & SmartContract>;
+    hooks: ProvableSettlementHook<unknown>[];
+    withdrawalStatePath: [string, string];
+    escapeHatchSlotsInterval: number;
+  };
+
+  @state(Field) public sequencerKey = State<Field>();
+  @state(UInt32) public lastSettlementL1Block = State<UInt32>();
+
+  @state(Field) public stateRoot = State<Field>();
+  @state(Field) public networkStateHash = State<Field>();
+  @state(Field) public blockHashRoot = State<Field>();
+
+  @state(Field) public dispatchContractAddressX = State<Field>();
+
+  @state(Field) public outgoingMessageCursor = State<Field>();
+
+  @method
+  public initialize(sequencer: PublicKey, dispatchContract: PublicKey) {
+    this.sequencerKey.getAndAssertEquals().assertEquals(Field(0));
+    this.stateRoot.getAndAssertEquals().assertEquals(Field(0));
+    this.blockHashRoot.getAndAssertEquals().assertEquals(Field(0));
+    this.networkStateHash.getAndAssertEquals().assertEquals(Field(0));
+    this.dispatchContractAddressX.getAndAssertEquals().assertEquals(Field(0));
+
+    this.sequencerKey.set(sequencer.x);
+    this.stateRoot.set(Field(RollupMerkleTree.EMPTY_ROOT));
+    this.blockHashRoot.set(Field(BlockHashMerkleTree.EMPTY_ROOT));
+    this.networkStateHash.set(NetworkState.empty().hash());
+    this.dispatchContractAddressX.set(dispatchContract.x);
+
+    const DispatchContract = SettlementSmartContract.args.DispatchContract;
+    new DispatchContract(dispatchContract).initialize(this.address);
+  }
+
+  @method
+  public settle(
+    blockProof: LazyBlockProof,
+    signature: Signature,
+    dispatchContractAddress: PublicKey,
+    publicKey: PublicKey,
+    inputNetworkState: NetworkState,
+    outputNetworkState: NetworkState,
+    newPromisedMessagesHash: Field
+  ) {
+    // Verify the blockproof
+    blockProof.verify();
+
+    // Get and assert on-chain values
+    const stateRoot = this.stateRoot.getAndAssertEquals();
+    const networkStateHash = this.networkStateHash.getAndAssertEquals();
+    const blockHashRoot = this.blockHashRoot.getAndAssertEquals();
+    const sequencerKey = this.sequencerKey.getAndAssertEquals();
+    const lastSettlementL1Block =
+      this.lastSettlementL1Block.getAndAssertEquals();
+    const onChainDispatchContractAddressX =
+      this.dispatchContractAddressX.getAndAssertEquals();
+
+    onChainDispatchContractAddressX.assertEquals(
+      dispatchContractAddress.x,
+      "DispatchContract address not provided correctly"
+    );
+
+    const { DispatchContract, escapeHatchSlotsInterval, hooks } =
+      SettlementSmartContract.args;
+
+    // Get dispatch contract values
+    // These values are witnesses but will be checked later on the AU
+    // call to the dispatch contract via .updateMessagesHash()
+    const dispatchContract = new DispatchContract(dispatchContractAddress);
+    const promisedMessagesHash = dispatchContract.promisedMessagesHash.get();
+
+    // Get block height and use the lower bound for all ops
+    const minBlockIncluded = this.network.globalSlotSinceGenesis.get();
+    this.network.globalSlotSinceGenesis.assertBetween(
+      minBlockIncluded,
+      // 5 because that is the length the newPromisedMessagesHash will be valid
+      minBlockIncluded.add(4)
+    );
+
+    // Check signature/escape catch
+    publicKey.x.assertEquals(
+      sequencerKey,
+      "Sequencer public key witness not matching"
+    );
+    const signatureValid = signature.verify(publicKey, [
+      BATCH_SIGNATURE_PREFIX,
+      lastSettlementL1Block.value,
+    ]);
+    const escapeHatchActivated = lastSettlementL1Block
+      .add(UInt32.from(escapeHatchSlotsInterval))
+      .lessThan(minBlockIncluded);
+    signatureValid
+      .or(escapeHatchActivated)
+      .assertTrue(
+        "Sequencer signature not valid and escape hatch not activated"
+      );
+
+    // Assert correctness of networkState witness
+    Provable.log("Network State Hash ", networkStateHash);
+    Provable.log("input Hash ", inputNetworkState.hash());
+    Provable.log("equals ", inputNetworkState.hash().equals(networkStateHash));
+
+    inputNetworkState
+      .hash()
+      .assertEquals(networkStateHash, "InputNetworkState witness not valid");
+    outputNetworkState
+      .hash()
+      .assertEquals(
+        blockProof.publicOutput.networkStateHash,
+        "OutputNetworkState witness not valid"
+      );
+
+    blockProof.publicOutput.closed.assertEquals(
+      Bool(true),
+      "Supplied proof is not a closed BlockProof"
+    );
+
+    // Execute onSettlementHooks for additional checks
+    const stateRecord: SettlementStateRecord = {
+      blockHashRoot,
+      stateRoot,
+      networkStateHash,
+      lastSettlementL1Block,
+      sequencerKey: publicKey,
+    };
+    const inputs: SettlementHookInputs = {
+      blockProof,
+      contractState: stateRecord,
+      newPromisedMessagesHash,
+      fromNetworkState: inputNetworkState,
+      toNetworkState: outputNetworkState,
+      currentL1Block: minBlockIncluded,
+    };
+    hooks.forEach((hook) => {
+      hook.beforeSettlement(this, inputs);
+    });
+
+    // Apply blockProof
+    stateRoot.assertEquals(
+      blockProof.publicInput.stateRoot,
+      "Input state root not matching"
+    );
+    Provable.log("Network State Hash ", networkStateHash);
+    Provable.log("input Hash ", inputNetworkState.hash());
+    Provable.log("Proof Hash ", blockProof.publicInput.networkStateHash);
+
+    networkStateHash.assertEquals(
+      blockProof.publicInput.networkStateHash,
+      "Input networkStateHash not matching"
+    );
+    blockHashRoot.assertEquals(
+      blockProof.publicInput.blockHashRoot,
+      "Input blockHashRoot not matching"
+    );
+    this.stateRoot.set(blockProof.publicOutput.stateRoot);
+    this.networkStateHash.set(blockProof.publicOutput.networkStateHash);
+    this.blockHashRoot.set(blockProof.publicOutput.blockHashRoot);
+
+    // Assert and apply deposit commitments
+    promisedMessagesHash.assertEquals(
+      blockProof.publicOutput.incomingMessagesHash,
+      "Promised messages not honored"
+    );
+
+    // Call DispatchContract
+    // This call checks that the promisedMessagesHash, which is already proven
+    // to be the blockProofs publicoutput, is actually the current on-chain
+    // promisedMessageHash. It also checks the newPromisedMessagesHash to be
+    // a current sequencestate value
+    dispatchContract.updateMessagesHash(
+      promisedMessagesHash,
+      newPromisedMessagesHash
+    );
+
+    this.lastSettlementL1Block.set(minBlockIncluded);
+  }
+
+  @method
+  public rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch) {
+    let counter = this.outgoingMessageCursor.getAndAssertEquals();
+    const stateRoot = this.stateRoot.getAndAssertEquals();
+
+    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.token.mint({ address, amount });
+      const isNewAccount = tokenAu.account.isNew.getAndAssertEquals();
+      tokenAu.body.balanceChange.magnitude =
+        tokenAu.body.balanceChange.magnitude.sub(
+          Provable.if(
+            isNewAccount,
+            Mina.accountCreationFee().toConstant(),
+            UInt64.zero
+          )
+        );
+
+      accountCreationFeePaid = accountCreationFeePaid.add(
+        Provable.if(isNewAccount, Field(1e9), Field(0))
+      );
+
+      counter = counter.add(Provable.if(isDummy, Field(0), Field(1)));
+    }
+
+    this.balance.subInPlace(UInt64.from(accountCreationFeePaid));
+
+    this.outgoingMessageCursor.set(counter);
+  }
+
+  @method
+  public redeem(additionUpdate: AccountUpdate) {
+    additionUpdate.body.tokenId.assertEquals(
+      TokenId.default,
+      "Tokenid not default token"
+    );
+    additionUpdate.body.balanceChange.sgn
+      .isPositive()
+      .assertTrue("Sign not correct");
+    const amount = additionUpdate.body.balanceChange.magnitude;
+
+    // Burn tokens
+    this.token.burn({
+      address: additionUpdate.publicKey,
+      amount,
+    });
+
+    // Send mina
+    this.approve(additionUpdate);
+    this.balance.subInPlace(amount);
+  }
+}

package/src/settlement/messages/Deposit.ts

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

package/src/settlement/messages/OutgoingMessageArgument.ts

@@ -0,0 +1,41 @@
+import { Bool, Provable, Struct } from "o1js";
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
+import { Withdrawal } from "./Withdrawal";
+
+export const OUTGOING_MESSAGE_BATCH_SIZE = 1;
+
+export class OutgoingMessageArgument extends Struct({
+  witness: RollupMerkleTreeWitness,
+  value: Withdrawal,
+}) {
+  public static dummy(): OutgoingMessageArgument {
+    return new OutgoingMessageArgument({
+      witness: RollupMerkleTreeWitness.dummy(),
+      value: Withdrawal.dummy(),
+    });
+  }
+}
+
+export class OutgoingMessageArgumentBatch extends Struct({
+  arguments: Provable.Array(
+    OutgoingMessageArgument,
+    OUTGOING_MESSAGE_BATCH_SIZE
+  ),
+
+  isDummys: Provable.Array(Bool, OUTGOING_MESSAGE_BATCH_SIZE),
+}) {
+  public static fromMessages(providedArguments: OutgoingMessageArgument[]) {
+    const batch = providedArguments.slice();
+    const isDummys = batch.map(() => Bool(false));
+
+    while (batch.length < OUTGOING_MESSAGE_BATCH_SIZE) {
+      batch.push(OutgoingMessageArgument.dummy());
+      isDummys.push(Bool(true));
+    }
+
+    return new OutgoingMessageArgumentBatch({
+      arguments: batch,
+      isDummys,
+    });
+  }
+}

package/src/settlement/messages/Withdrawal.ts

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

package/src/settlement/modularity/ProvableSettlementHook.ts

@@ -0,0 +1,34 @@
+import { Field, PublicKey, UInt32 } from "o1js";
+
+import type { BlockProof } from "../../prover/block/BlockProver";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { NetworkState } from "../../model/network/NetworkState";
+
+import type { SettlementSmartContract } from "../contracts/SettlementSmartContract";
+
+export type SettlementStateRecord = {
+  sequencerKey: PublicKey;
+  lastSettlementL1Block: UInt32;
+
+  stateRoot: Field;
+  networkStateHash: Field;
+  blockHashRoot: Field;
+};
+
+export type SettlementHookInputs = {
+  blockProof: BlockProof;
+  fromNetworkState: NetworkState;
+  toNetworkState: NetworkState;
+  newPromisedMessagesHash: Field;
+  contractState: SettlementStateRecord;
+  currentL1Block: UInt32;
+};
+
+export abstract class ProvableSettlementHook<
+  Config
+> extends ProtocolModule<Config> {
+  public abstract beforeSettlement(
+    smartContract: SettlementSmartContract,
+    inputs: SettlementHookInputs
+  ): void;
+}

package/src/settlement/modules/NetworkStateSettlementModule.ts

@@ -0,0 +1,39 @@
+import { UInt64 } from "o1js";
+
+import {
+  ProvableSettlementHook,
+  SettlementHookInputs,
+} from "../modularity/ProvableSettlementHook";
+import { SettlementSmartContract } from "../contracts/SettlementSmartContract";
+
+type NetworkStateSettlementModuleConfig = {
+  blocksPerL1Block: UInt64;
+};
+
+export class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
+  public beforeSettlement(
+    smartContract: SettlementSmartContract,
+    {
+      blockProof,
+      fromNetworkState,
+      toNetworkState,
+      contractState,
+      currentL1Block,
+    }: SettlementHookInputs
+  ): void {
+    const { lastSettlementL1Block } = contractState;
+
+    const blocksPerL1Block = this.config.blocksPerL1Block.toConstant();
+
+    const numL1Blocks = currentL1Block.sub(lastSettlementL1Block);
+    const expectedHeightDiff = numL1Blocks.toUInt64().mul(blocksPerL1Block);
+
+    const actualHeightDiff = toNetworkState.block.height.sub(
+      fromNetworkState.block.height
+    );
+
+    const acceptableDerivation = numL1Blocks.mul(1).div(10);
+
+    // TODO Check within bounds efficiently
+  }
+}

package/src/state/State.ts

@@ -72,7 +72,8 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
       .current().result;
 
     // First try to find a match inside already created stateTransitions
-    const previousMutatingTransitions = stateTransitions.filter((transition) =>
+    let previousMutatingTransitions: StateTransition<any>[] = [];
+    previousMutatingTransitions = stateTransitions.filter((transition) =>
       transition.path.equals(path).and(transition.to.isSome).toBoolean()
     );
     const pmtLength = previousMutatingTransitions.length;

package/src/state/assert/assert.ts

@@ -1,4 +1,4 @@
-import { Bool } from "o1js";
+import { Bool, Provable } from "o1js";
 import { container } from "tsyringe";
 import { log } from "@proto-kit/common";
 
@@ -18,12 +18,14 @@ export function assert(condition: Bool, message?: string) {
   const previousStatus = executionContext.current().result.status;
   const status = condition.and(previousStatus);
 
-  if (!condition.toBoolean()) {
-    if (!executionContext.current().isSimulated) {
-      log.debug("Assertion failed: ", message);
+  Provable.asProver(() => {
+    if (!condition.toBoolean()) {
+      if (!executionContext.current().isSimulated) {
+        log.debug("Assertion failed: ", message);
+      }
+      executionContext.setStatusMessage(message);
     }
-    executionContext.setStatusMessage(message);
-  }
+  });
 
   executionContext.setStatus(status);
 }

package/src/state/context/RuntimeMethodExecutionContext.ts

@@ -1,4 +1,4 @@
-import { Bool } from "o1js";
+import { Bool, Provable, Struct } from "o1js";
 import { singleton } from "tsyringe";
 import {
   ProvableMethodExecutionContext,
@@ -29,6 +29,13 @@ export interface RuntimeMethodExecutionData {
   networkState: NetworkState;
 }
 
+export class RuntimeMethodExecutionDataStruct
+  extends Struct({
+    transaction: RuntimeTransaction,
+    networkState: NetworkState,
+  })
+  implements RuntimeMethodExecutionData {}
+
 /**
  * Execution context used to wrap runtime module methods,
  * allowing them to post relevant information (such as execution status)
@@ -93,6 +100,18 @@ export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContex
     this.input = input;
   }
 
+  public witnessInput(): RuntimeMethodExecutionDataStruct {
+    this.assertSetupCalled();
+    return Provable.witness(RuntimeMethodExecutionDataStruct, () => {
+      // TODO Is that right? Or this.current().input
+      const { transaction, networkState } = this.input!;
+      return new RuntimeMethodExecutionDataStruct({
+        networkState,
+        transaction,
+      });
+    });
+  }
+
   public setSimulated(simulated: boolean) {
     this.isSimulated = simulated;
   }
@@ -108,7 +127,8 @@ export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContex
     super.afterMethod();
     if (this.isFinished) {
       this.lastInput = this.input;
-      this.input = undefined;
+      // TODO: find out why input isnt set in TransactionFeeHook during assert
+      // this.input = undefined;
       this.isSimulated = false;
     }
   }

package/src/utils/MinaPrefixedProvableHashList.ts

@@ -0,0 +1,72 @@
+import { Field, Poseidon, ProvablePure } from "o1js";
+import { hashWithPrefix, prefixToField } from "@proto-kit/common";
+
+import { ProvableHashList } from "./ProvableHashList";
+
+function salt(prefix: string) {
+  return Poseidon.update(
+    [Field(0), Field(0), Field(0)],
+    [prefixToField(prefix)]
+  ) as [Field, Field, Field];
+}
+
+export const MINA_EVENT_PREFIXES = {
+  event: "MinaZkappEvent******",
+  events: "MinaZkappEvents*****",
+  sequenceEvents: "MinaZkappSeqEvents**",
+} as const;
+
+export function emptyActions(): Field {
+  return salt("MinaZkappActionsEmpty")[0];
+}
+
+export function emptyEvents(): Field {
+  return salt("MinaZkappEventsEmpty")[0];
+}
+
+export class MinaActions {
+  static actionHash(
+    action: Field[],
+    previousHash: Field = emptyActions()
+  ): Field {
+    const actionDataHash = hashWithPrefix(MINA_EVENT_PREFIXES.event, action);
+    return hashWithPrefix(MINA_EVENT_PREFIXES.sequenceEvents, [
+      previousHash,
+      actionDataHash,
+    ]);
+  }
+}
+
+export class MinaEvents {
+  static eventHash(event: Field[], previousHash: Field = emptyEvents()): Field {
+    const actionDataHash = hashWithPrefix(MINA_EVENT_PREFIXES.event, event);
+    return hashWithPrefix(MINA_EVENT_PREFIXES.events, [
+      previousHash,
+      actionDataHash,
+    ]);
+  }
+}
+
+export class MinaPrefixedProvableHashList<
+  Value
+> extends ProvableHashList<Value> {
+  public constructor(
+    valueType: ProvablePure<Value>,
+    public readonly prefix: string,
+    internalCommitment: Field = Field(0)
+  ) {
+    super(valueType, internalCommitment);
+  }
+
+  protected hash(elements: Field[]): Field {
+    const init = salt(this.prefix);
+    const digest = Poseidon.update(init, elements);
+    return digest[0];
+  }
+}
+
+export class MinaActionsHashList extends MinaPrefixedProvableHashList<Field> {
+  public constructor(internalCommitment: Field = Field(0)) {
+    super(Field, MINA_EVENT_PREFIXES.sequenceEvents, internalCommitment);
+  }
+}

package/src/utils/PrefixedProvableHashList.ts

@@ -1,4 +1,4 @@
-import { Field, FlexibleProvablePure, Poseidon } from "o1js";
+import { Field, ProvablePure, Poseidon } from "o1js";
 
 import { ProvableHashList } from "./ProvableHashList.js";
 import { stringToField } from "./utils";
@@ -7,7 +7,7 @@ export class PrefixedProvableHashList<Value> extends ProvableHashList<Value> {
   private readonly prefix: Field;
 
   public constructor(
-    valueType: FlexibleProvablePure<Value>,
+    valueType: ProvablePure<Value>,
     prefix: string,
     internalCommitment: Field = Field(0)
   ) {

package/src/utils/ProvableHashList.ts

@@ -1,11 +1,11 @@
-import { Field, Poseidon, FlexibleProvablePure, Bool, Provable } from "o1js";
+import { Field, Poseidon, Bool, Provable, ProvablePure } from "o1js";
 
 /**
  * Utilities for creating a hash list from a given value type.
  */
 export abstract class ProvableHashList<Value> {
   public constructor(
-    private readonly valueType: FlexibleProvablePure<Value>,
+    protected readonly valueType: ProvablePure<Value>,
     public commitment: Field = Field(0)
   ) {}
 
@@ -47,4 +47,4 @@ export class DefaultProvableHashList<Value> extends ProvableHashList<Value> {
   public hash(elements: Field[]): Field {
     return Poseidon.hash(elements);
   }
-}
+}