@proto-kit/protocol 0.1.1-develop.456 → 0.1.1-develop.600

package/dist/state/context/RuntimeMethodExecutionContext.d.ts

@@ -1,4 +1,4 @@
-import { Bool } from "o1js";
+import { Bool, Provable } from "o1js";
 import { ProvableMethodExecutionContext, ProvableMethodExecutionResult } from "@proto-kit/common";
 import { StateTransition } from "../../model/StateTransition";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
@@ -12,6 +12,78 @@ export interface RuntimeMethodExecutionData {
     transaction: RuntimeTransaction;
     networkState: NetworkState;
 }
+declare const RuntimeMethodExecutionDataStruct_base: (new (value: {
+    transaction: RuntimeTransaction;
+    networkState: NetworkState;
+}) => {
+    transaction: RuntimeTransaction;
+    networkState: NetworkState;
+}) & {
+    _isStruct: true;
+} & Provable<{
+    transaction: RuntimeTransaction;
+    networkState: NetworkState;
+}> & {
+    toInput: (x: {
+        transaction: RuntimeTransaction;
+        networkState: NetworkState;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transaction: RuntimeTransaction;
+        networkState: NetworkState;
+    }) => {
+        transaction: {
+            methodId: string;
+            argsHash: string;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
+        };
+        networkState: {
+            block: {
+                height: string;
+            };
+            previous: {
+                rootHash: string;
+            };
+        };
+    };
+    fromJSON: (x: {
+        transaction: {
+            methodId: string;
+            argsHash: string;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
+        };
+        networkState: {
+            block: {
+                height: string;
+            };
+            previous: {
+                rootHash: string;
+            };
+        };
+    }) => {
+        transaction: RuntimeTransaction;
+        networkState: NetworkState;
+    };
+};
+export declare class RuntimeMethodExecutionDataStruct extends RuntimeMethodExecutionDataStruct_base {
+}
 /**
  * Execution context used to wrap runtime module methods,
  * allowing them to post relevant information (such as execution status)
@@ -41,6 +113,7 @@ export declare class RuntimeMethodExecutionContext extends ProvableMethodExecuti
      * @param input Input witness data required for a runtime execution
      */
     setup(input: RuntimeMethodExecutionData): void;
+    witnessInput(): RuntimeMethodExecutionDataStruct;
     setSimulated(simulated: boolean): void;
     /**
      * Manually clears/resets the execution context
@@ -58,4 +131,5 @@ export declare class RuntimeMethodExecutionContext extends ProvableMethodExecuti
         isSimulated: boolean;
     };
 }
+export {};
 //# sourceMappingURL=RuntimeMethodExecutionContext.d.ts.map

package/dist/state/context/RuntimeMethodExecutionContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuntimeMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../../src/state/context/RuntimeMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAShE,qBAAa,oCAAqC,SAAQ,6BAA6B;IAE9E,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAM;IAE9C,MAAM,EAAE,IAAI,CAAc;IAE1B,aAAa,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,kBAAkB,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;;GAIG;AACH,qBACa,6BAA8B,SAAQ,8BAA8B;IACxE,OAAO,EAAE,MAAM,EAAE,CAAM;IAEvB,KAAK,EAAE,0BAA0B,GAAG,SAAS,CAAC;IAGrD,OAAO,CAAC,SAAS,CAAyC;IAE1C,MAAM,uCAA8C;IAEpE,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO,CAAC,iBAAiB;IAQzB;;;OAGG;IACI,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;IAKxE;;OAEG;IACI,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM;IAQxC;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,IAAI;IAQ7B;;OAEG;IACI,KAAK,CAAC,KAAK,EAAE,0BAA0B;IAIvC,YAAY,CAAC,SAAS,EAAE,OAAO;IAItC;;OAEG;IACI,KAAK;IAIL,WAAW;IASlB;;;OAGG;IACI,OAAO;;;;;;CAQf"}
+{"version":3,"file":"RuntimeMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../../src/state/context/RuntimeMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAU,MAAM,MAAM,CAAC;AAE9C,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAShE,qBAAa,oCAAqC,SAAQ,6BAA6B;IAE9E,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAM;IAE9C,MAAM,EAAE,IAAI,CAAc;IAE1B,aAAa,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,kBAAkB,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,gCAAiC,SAAQ,qCAGpD;CAAG;AAEL;;;;GAIG;AACH,qBACa,6BAA8B,SAAQ,8BAA8B;IACxE,OAAO,EAAE,MAAM,EAAE,CAAM;IAEvB,KAAK,EAAE,0BAA0B,GAAG,SAAS,CAAC;IAGrD,OAAO,CAAC,SAAS,CAAyC;IAE1C,MAAM,uCAA8C;IAEpE,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO,CAAC,iBAAiB;IAQzB;;;OAGG;IACI,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;IAKxE;;OAEG;IACI,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM;IAQxC;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,IAAI;IAQ7B;;OAEG;IACI,KAAK,CAAC,KAAK,EAAE,0BAA0B;IAIvC,YAAY,IAAI,gCAAgC;IAYhD,YAAY,CAAC,SAAS,EAAE,OAAO;IAItC;;OAEG;IACI,KAAK;IAIL,WAAW;IASlB;;;OAGG;IACI,OAAO;;;;;;CAQf"}

package/dist/state/context/RuntimeMethodExecutionContext.js

@@ -4,9 +4,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Bool } from "o1js";
+import { Bool, Provable, Struct } from "o1js";
 import { singleton } from "tsyringe";
 import { ProvableMethodExecutionContext, ProvableMethodExecutionResult, } from "@proto-kit/common";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
 const errors = {
     setupNotCalled: () => new Error("Setup has not been called prior to executing a runtime method. Be sure to do that so that the Runtime is setup property for execution"),
 };
@@ -18,6 +20,11 @@ export class RuntimeProvableMethodExecutionResult extends ProvableMethodExecutio
         this.status = Bool(true);
     }
 }
+export class RuntimeMethodExecutionDataStruct extends Struct({
+    transaction: RuntimeTransaction,
+    networkState: NetworkState,
+}) {
+}
 /**
  * Execution context used to wrap runtime module methods,
  * allowing them to post relevant information (such as execution status)
@@ -70,6 +77,17 @@ let RuntimeMethodExecutionContext = class RuntimeMethodExecutionContext extends
     setup(input) {
         this.input = input;
     }
+    witnessInput() {
+        this.assertSetupCalled();
+        return Provable.witness(RuntimeMethodExecutionDataStruct, () => {
+            // TODO Is that right? Or this.current().input
+            const { transaction, networkState } = this.input;
+            return new RuntimeMethodExecutionDataStruct({
+                networkState,
+                transaction,
+            });
+        });
+    }
     setSimulated(simulated) {
         this.isSimulated = simulated;
     }

package/dist/utils/MinaPrefixedProvableHashList.d.ts

@@ -0,0 +1,24 @@
+import { Field, FlexibleProvablePure } from "o1js";
+import { ProvableHashList } from "./ProvableHashList";
+export declare const MINA_EVENT_PREFIXES: {
+    readonly event: "MinaZkappEvent******";
+    readonly events: "MinaZkappEvents*****";
+    readonly sequenceEvents: "MinaZkappSeqEvents**";
+};
+export declare function emptyActions(): Field;
+export declare function emptyEvents(): Field;
+export declare class MinaActions {
+    static actionHash(action: Field[], previousHash?: Field): Field;
+}
+export declare class MinaEvents {
+    static eventHash(event: Field[], previousHash?: Field): Field;
+}
+export declare class MinaPrefixedProvableHashList<Value> extends ProvableHashList<Value> {
+    readonly prefix: string;
+    constructor(valueType: FlexibleProvablePure<Value>, prefix: string, internalCommitment?: Field);
+    protected hash(elements: Field[]): Field;
+}
+export declare class MinaActionsHashList extends MinaPrefixedProvableHashList<Field> {
+    constructor(internalCommitment?: Field);
+}
+//# sourceMappingURL=MinaPrefixedProvableHashList.d.ts.map

package/dist/utils/MinaPrefixedProvableHashList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinaPrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/MinaPrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAY,MAAM,MAAM,CAAC;AAG7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAStD,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,wBAAgB,YAAY,IAAI,KAAK,CAEpC;AAED,wBAAgB,WAAW,IAAI,KAAK,CAEnC;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,KAAK,EAAE,EACf,YAAY,GAAE,KAAsB,GACnC,KAAK;CAOT;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,YAAY,GAAE,KAAqB,GAAG,KAAK;CAO7E;AAED,qBAAa,4BAA4B,CACvC,KAAK,CACL,SAAQ,gBAAgB,CAAC,KAAK,CAAC;aAGb,MAAM,EAAE,MAAM;gBAD9B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EACtB,MAAM,EAAE,MAAM,EAC9B,kBAAkB,GAAE,KAAgB;IAKtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAKzC;AAED,qBAAa,mBAAoB,SAAQ,4BAA4B,CAAC,KAAK,CAAC;gBACvD,kBAAkB,GAAE,KAAgB;CAGxD"}

package/dist/utils/MinaPrefixedProvableHashList.js

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

package/package.json

@@ -3,7 +3,7 @@
   "license": "MIT",
   "private": false,
   "type": "module",
-  "version": "0.1.1-develop.456+bdb345d",
+  "version": "0.1.1-develop.600+699a7df",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
@@ -32,5 +32,5 @@
     "@jest/globals": "^29.5.0",
     "@types/lodash": "^4.14.194"
   },
-  "gitHead": "bdb345d9e6132387a870c8a4236d8fe295502ce4"
+  "gitHead": "699a7dfa3b5d3415ab4500f0cd495d6781365c6a"
 }

package/src/blockmodules/AccountStateModule.ts

@@ -1,4 +1,4 @@
-import { PublicKey, Struct, UInt64 } from "o1js";
+import { Provable, PublicKey, Struct, UInt64 } from "o1js";
 
 import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 import { StateMap } from "../state/StateMap";
@@ -17,17 +17,28 @@ export class AccountStateModule extends ProvableTransactionHook {
   );
 
   public onTransaction({ transaction }: BlockProverExecutionData): void {
+    const sender = transaction.sender.value;
+
     const accountState = this.accountState
-      .get(transaction.sender)
+      .get(sender)
       .orElse(new AccountState({ nonce: UInt64.zero }));
 
     const currentNonce = accountState.nonce;
 
-    assert(currentNonce.equals(transaction.nonce), "Nonce not matching");
+    // Either the nonce matches or the tx is a message, in which case we don't care
+    assert(
+      currentNonce
+        .equals(transaction.nonce.value)
+        .or(transaction.sender.isSome.not()),
+      "Nonce not matching"
+    );
 
-    this.accountState.set(
-      transaction.sender,
-      new AccountState({ nonce: currentNonce.add(1) })
+    // Optimized version of transaction.sender.isSome ? currentNonce.add(1) : Field(0)
+    // Bcs Bool(true).toField() == 1
+    const newNonce = UInt64.from(
+      currentNonce.value.add(1).mul(transaction.sender.isSome.toField())
     );
+
+    this.accountState.set(sender, new AccountState({ nonce: newNonce }));
   }
 }

package/src/blockmodules/BlockHeightHook.ts

@@ -1,21 +1,18 @@
 import { Provable } from "o1js";
 import { NetworkState } from "../model/network/NetworkState";
-import {
-  AfterBlockParameters,
-  BeforeBlockParameters,
-  ProvableBlockHook,
-} from "../protocol/ProvableBlockHook";
+import { ProvableBlockHook } from "../protocol/ProvableBlockHook";
 
 export class BlockHeightHook extends ProvableBlockHook<Record<string, never>> {
-  public afterBlock({ networkState }: AfterBlockParameters): NetworkState {
+  public afterBlock(networkState: NetworkState): NetworkState {
     return new NetworkState({
       block: {
         height: networkState.block.height.add(1),
       },
+      previous: networkState.previous
     });
   }
 
-  public beforeBlock(blockData: BeforeBlockParameters): NetworkState {
-    return blockData.networkState;
+  public beforeBlock(networkState: NetworkState): NetworkState {
+    return networkState;
   }
 }

package/src/blockmodules/LastStateRootBlockHook.ts

@@ -0,0 +1,26 @@
+import { ProvableBlockHook } from "../protocol/ProvableBlockHook";
+import { NetworkState } from "../model/network/NetworkState";
+import { BlockProverState } from "../prover/block/BlockProver";
+
+export class LastStateRootBlockHook extends ProvableBlockHook<
+  Record<string, never>
+> {
+  public afterBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): NetworkState {
+    return new NetworkState({
+      block: networkState.block,
+      previous: {
+        rootHash: state.stateRoot,
+      },
+    });
+  }
+
+  public beforeBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): NetworkState {
+    return networkState;
+  }
+}

package/src/blockmodules/NoopBlockHook.ts

@@ -1,16 +1,20 @@
-import {
-  AfterBlockParameters,
-  BeforeBlockParameters,
-  ProvableBlockHook
-} from "../protocol/ProvableBlockHook";
+import { ProvableBlockHook } from "../protocol/ProvableBlockHook";
 import { NetworkState } from "../model/network/NetworkState";
+import { BlockProverState } from "../prover/block/BlockProver";
+import { NoConfig } from "@proto-kit/common";
 
-export class NoopBlockHook extends ProvableBlockHook<Record<string, never>>{
-  public afterBlock(blockData: AfterBlockParameters): NetworkState {
-    return blockData.networkState;
+export class NoopBlockHook extends ProvableBlockHook<NoConfig> {
+  public afterBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): NetworkState {
+    return networkState;
   }
 
-  public beforeBlock(blockData: BeforeBlockParameters): NetworkState {
-    return blockData.networkState;
+  public beforeBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): NetworkState {
+    return networkState;
   }
-}
+}

package/src/blockmodules/NoopSettlementHook.ts

@@ -0,0 +1,21 @@
+import { injectable } from "tsyringe";
+import { noop } from "@proto-kit/common";
+import { SmartContract } from "o1js";
+
+import { BlockProof } from "../prover/block/BlockProver";
+import {
+  ProvableSettlementHook,
+  SettlementHookInputs,
+} from "../settlement/ProvableSettlementHook";
+
+@injectable()
+export class NoopSettlementHook extends ProvableSettlementHook<
+  Record<string, never>
+> {
+  public beforeSettlement(
+    contract: SmartContract,
+    state: SettlementHookInputs
+  ): void {
+    noop();
+  }
+}

package/src/blockmodules/SequenceStateTransactionModule.ts

@@ -0,0 +1,25 @@
+import { Field } from "o1js";
+
+import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
+import { BlockProverExecutionData } from "../prover/block/BlockProvable";
+import { protocolState } from "../state/protocol/ProtocolState";
+import { State } from "../state/State";
+import { DefaultProvableHashList } from "../utils/ProvableHashList";
+import { SignedTransaction } from "../model/transaction/SignedTransaction";
+
+// Future idea to add this functionality as a module
+// This is currently hardcoded in tracing however
+class SequenceStateTransactionModule extends ProvableTransactionHook {
+  @protocolState() sequenceStateTransactionsList = State.from(Field);
+
+  public onTransaction(executionData: BlockProverExecutionData): void {
+    const hashList = new DefaultProvableHashList(
+      SignedTransaction,
+      this.sequenceStateTransactionsList.get().orElse(Field(0))
+    );
+
+    hashList.push(executionData.transaction);
+
+    this.sequenceStateTransactionsList.set(hashList.commitment);
+  }
+}

package/src/index.ts

@@ -1,18 +1,21 @@
 export * from "./blockmodules/AccountStateModule";
 export * from "./blockmodules/BlockHeightHook";
+export * from "./blockmodules/LastStateRootBlockHook";
 export * from "./utils/ProvableHashList";
 export * from "./model/StateTransition";
 export * from "./model/StateTransitionProvableBatch";
 export * from "./model/Option";
 export * from "./model/Path";
 export * from "./model/network/NetworkState";
-export * from "./model/transaction/ProtocolTransaction";
+export * from "./model/transaction/SignedTransaction";
 export * from "./model/transaction/RuntimeTransaction";
-export * from "./utils/PrefixedProvableHashList.js";
+export * from "./model/transaction/ValueOption";
+export * from "./utils/PrefixedProvableHashList";
+export * from "./utils/MinaPrefixedProvableHashList";
 export * from "./utils/utils";
 export * from "./prover/block/BlockProver";
 export * from "./prover/block/BlockProvable";
-export * from "./prover/block/BlockTransactionPosition";
+export * from "./prover/block/accummulators/BlockHashMerkleTree";
 export * from "./prover/statetransition/StateTransitionProver";
 export * from "./prover/statetransition/StateTransitionProvable";
 export * from "./prover/statetransition/StateTransitionWitnessProvider";
@@ -32,4 +35,7 @@ export * from "./state/StateMap";
 export * from "./state/StateService";
 export * from "./state/StateServiceProvider";
 export * from "./state/assert/assert";
+export * from "./settlement/SettlementContract";
+export * from "./settlement/ProvableSettlementHook";
+export * from "./settlement/modules/NetworkStateSettlementModule";
 export { constants as ProtocolConstants } from "./Constants";

package/src/model/MethodPublicOutput.ts

@@ -1,4 +1,4 @@
-import { Bool, Field, Struct } from "o1js";
+import { Bool, Field, Signature, Struct } from "o1js";
 
 /**
  * Public input used to link in-circuit execution with
@@ -9,4 +9,5 @@ export class MethodPublicOutput extends Struct({
   status: Bool,
   transactionHash: Field,
   networkStateHash: Field,
-}) {}
+  isMessage: Bool,
+}) {}

package/src/model/network/NetworkState.ts

@@ -1,21 +1,33 @@
 import { Field, Poseidon, Struct, UInt64 } from "o1js";
+import { RollupMerkleTree } from "@proto-kit/common";
 
 export class CurrentBlock extends Struct({
   height: UInt64,
 }) {}
 
+export class PreviousBlock extends Struct({
+  rootHash: Field,
+}) {}
+
 export class NetworkState extends Struct({
   block: CurrentBlock,
+  previous: PreviousBlock,
 }) {
   public hash(): Field {
-    return Poseidon.hash(CurrentBlock.toFields(this.block));
+    return Poseidon.hash([
+      ...CurrentBlock.toFields(this.block),
+      ...PreviousBlock.toFields(this.previous),
+    ]);
   }
 
-  public static empty(){
+  public static empty() {
     return new NetworkState({
       block: {
         height: UInt64.zero,
       },
-    })
+      previous: {
+        rootHash: Field(RollupMerkleTree.EMPTY_ROOT)
+      }
+    });
   }
 }

package/src/model/transaction/RuntimeTransaction.ts

@@ -1,6 +1,14 @@
-import { Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
-
-import { ProtocolTransaction } from "./ProtocolTransaction";
+import {
+  Bool,
+  Field,
+  Poseidon,
+  Provable,
+  PublicKey,
+  Struct,
+  UInt64,
+} from "o1js";
+import { PublicKeyOption, UInt64Option } from "./ValueOption";
+import { EMPTY_PUBLICKEY, EMPTY_PUBLICKEY_X } from "@proto-kit/common";
 
 /**
  * This struct is used to expose transaction information to the runtime method
@@ -9,30 +17,96 @@ import { ProtocolTransaction } from "./ProtocolTransaction";
  */
 export class RuntimeTransaction extends Struct({
   methodId: Field,
-  nonce: UInt64,
-  sender: PublicKey,
   argsHash: Field,
+  nonce: UInt64Option,
+  sender: PublicKeyOption,
 }) {
-  public static fromProtocolTransaction({
+  public static fromTransaction(input: {
+    methodId: Field;
+    argsHash: Field;
+    nonce: UInt64;
+    sender: PublicKey;
+  }) {
+    return new RuntimeTransaction({
+      methodId: input.methodId,
+      argsHash: input.argsHash,
+      nonce: UInt64Option.fromValue(input.nonce),
+      sender: PublicKeyOption.fromValue(input.sender),
+    });
+  }
+
+  public static fromMessage({
     methodId,
-    nonce,
-    sender,
     argsHash,
-  }: ProtocolTransaction): RuntimeTransaction {
+  }: {
+    methodId: Field;
+    argsHash: Field;
+  }) {
     return new RuntimeTransaction({
       methodId,
-      nonce,
-      sender,
       argsHash,
+      nonce: UInt64Option.none(UInt64.zero),
+      sender: PublicKeyOption.none(EMPTY_PUBLICKEY),
     });
   }
 
-  public hash(): Field {
-    return Poseidon.hash([
+  public static dummyTransaction(): RuntimeTransaction {
+    return new RuntimeTransaction({
+      methodId: Field(0),
+      nonce: new UInt64Option({
+        isSome: Bool(true),
+        value: UInt64.zero,
+      }),
+      sender: new PublicKeyOption({
+        isSome: Bool(true),
+        value: EMPTY_PUBLICKEY,
+      }),
+      argsHash: Field(0),
+    });
+  }
+
+  public assertTransactionType(isMessage: Bool) {
+    const isTransaction = isMessage.not();
+    // isSome has to be true when it is a transaction, otherwise false
+    this.nonce.isSome
+      .equals(isTransaction)
+      .assertTrue("Nonce is not right option isSome for type");
+    this.sender.isSome
+      .equals(isTransaction)
+      .assertTrue("Sender is not right option isSome for type");
+    this.sender.value.x
+      .equals(EMPTY_PUBLICKEY_X)
+      .equals(isMessage)
+      .assertTrue("Transaction sender is not set to dummy");
+  }
+
+  public hashData(): Field[] {
+    return [
       this.methodId,
-      ...this.sender.toFields(),
-      ...this.nonce.toFields(),
+      ...this.sender.value.toFields(),
+      ...this.nonce.value.toFields(),
       this.argsHash,
-    ]);
+    ];
+  }
+
+  public static fromHashData(fields: Field[]) {
+    // sender is 2nd and the first element is x (2nd isOdd)
+    const isMessage = fields[1].equals(EMPTY_PUBLICKEY_X);
+    return new RuntimeTransaction({
+      methodId: fields[0],
+      sender: new PublicKeyOption({
+        isSome: isMessage.not(),
+        value: PublicKey.fromFields([fields[1], fields[2]]),
+      }),
+      nonce: new UInt64Option({
+        isSome: isMessage.not(),
+        value: UInt64.fromFields([fields[3]]),
+      }),
+      argsHash: fields[4],
+    });
+  }
+
+  public hash(): Field {
+    return Poseidon.hash(this.hashData());
   }
 }