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

package/src/prover/statetransition/StateTransitionProver.ts

@@ -1,36 +1,34 @@
-/* eslint-disable max-lines */
-import { Bool, Experimental, Field, Provable, SelfProof } from "o1js";
-import { injectable } from "tsyringe";
 import {
   AreProofsEnabled,
-  log,
   PlainZkProgram,
   provableMethod,
   RollupMerkleTreeWitness,
   ZkProgrammable,
 } from "@proto-kit/common";
+import { Field, Provable, SelfProof, ZkProgram } from "o1js";
+import { injectable } from "tsyringe";
 
-import {
-  DefaultProvableHashList,
-  ProvableHashList,
-} from "../../utils/ProvableHashList";
+import { constants } from "../../Constants";
 import { ProvableStateTransition } from "../../model/StateTransition";
 import {
   ProvableStateTransitionType,
   StateTransitionProvableBatch,
 } from "../../model/StateTransitionProvableBatch";
-import { constants } from "../../Constants";
+import { StateTransitionProverType } from "../../protocol/Protocol";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
+import {
+  DefaultProvableHashList,
+  ProvableHashList,
+} from "../../utils/ProvableHashList";
 
-import { StateTransitionWitnessProvider } from "./StateTransitionWitnessProvider";
 import {
+  StateTransitionProof,
   StateTransitionProvable,
   StateTransitionProverPublicInput,
-  StateTransitionProof,
   StateTransitionProverPublicOutput,
 } from "./StateTransitionProvable";
+import { StateTransitionWitnessProvider } from "./StateTransitionWitnessProvider";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
-import { StateTransitionProverType } from "../../protocol/Protocol";
 
 const errors = {
   propertyNotMatching: (property: string, step: string) =>
@@ -66,7 +64,6 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
   StateTransitionProverPublicOutput
 > {
   public constructor(
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
     private readonly stateTransitionProver: StateTransitionProver,
     public readonly witnessProviderReference: StateTransitionWitnessProviderReference
   ) {
@@ -81,11 +78,10 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
     StateTransitionProverPublicInput,
     StateTransitionProverPublicOutput
   > {
-    // eslint-disable-next-line max-len
-    // eslint-disable-next-line @typescript-eslint/no-this-alias,consistent-this,unicorn/no-this-assignment
     const instance = this;
 
-    const program = Experimental.ZkProgram({
+    const program = ZkProgram({
+      name: "StateTransitionProver",
       publicInput: StateTransitionProverPublicInput,
       publicOutput: StateTransitionProverPublicOutput,
 
@@ -93,11 +89,11 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
         proveBatch: {
           privateInputs: [StateTransitionProvableBatch],
 
-          method(
+          async method(
             publicInput: StateTransitionProverPublicInput,
             batch: StateTransitionProvableBatch
           ) {
-            return instance.runBatch(publicInput, batch);
+            return await instance.runBatch(publicInput, batch);
           },
         },
 
@@ -107,12 +103,12 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
             StateTransitionSelfProofClass,
           ],
 
-          method(
+          async method(
             publicInput: StateTransitionProverPublicInput,
             proof1: StateTransitionProof,
             proof2: StateTransitionProof
           ) {
-            return instance.merge(publicInput, proof1, proof2);
+            return await instance.merge(publicInput, proof1, proof2);
           },
         },
       },
@@ -123,7 +119,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
       merge: program.merge.bind(program),
     };
 
-    const SelfProofClass = Experimental.ZkProgram.Proof(program);
+    const SelfProofClass = ZkProgram.Proof(program);
 
     return {
       compile: program.compile.bind(program),
@@ -242,10 +238,10 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
    * Applies a whole batch of StateTransitions at once
    */
   @provableMethod()
-  public runBatch(
+  public async runBatch(
     publicInput: StateTransitionProverPublicInput,
     batch: StateTransitionProvableBatch
-  ): StateTransitionProverPublicOutput {
+  ): Promise<StateTransitionProverPublicOutput> {
     const result = this.applyTransitions(
       publicInput.stateRoot,
       publicInput.protocolStateRoot,
@@ -263,11 +259,11 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
   }
 
   @provableMethod()
-  public merge(
+  public async merge(
     publicInput: StateTransitionProverPublicInput,
     proof1: StateTransitionProof,
     proof2: StateTransitionProof
-  ): StateTransitionProverPublicOutput {
+  ): Promise<StateTransitionProverPublicOutput> {
     proof1.verify();
     proof2.verify();
 
@@ -359,7 +355,7 @@ export class StateTransitionProver
   public runBatch(
     publicInput: StateTransitionProverPublicInput,
     batch: StateTransitionProvableBatch
-  ): StateTransitionProverPublicOutput {
+  ): Promise<StateTransitionProverPublicOutput> {
     return this.zkProgrammable.runBatch(publicInput, batch);
   }
 
@@ -367,7 +363,7 @@ export class StateTransitionProver
     publicInput: StateTransitionProverPublicInput,
     proof1: StateTransitionProof,
     proof2: StateTransitionProof
-  ): StateTransitionProverPublicOutput {
+  ): Promise<StateTransitionProverPublicOutput> {
     return this.zkProgrammable.merge(publicInput, proof1, proof2);
   }
 }

package/src/settlement/ContractModule.ts

@@ -16,7 +16,7 @@ export abstract class ContractModule<
   ContractType,
   // undefined = no args
   Arguments = undefined,
-  Config = NoConfig
+  Config = NoConfig,
 > extends ConfigurableModule<Config> {
   public abstract contractFactory(
     args: Arguments

package/src/settlement/SettlementContractModule.ts

@@ -2,8 +2,9 @@ import {
   AreProofsEnabled,
   ChildContainerProvider,
   ModuleContainer,
-  ModulesRecord, ResolvableModules, StringKeyOf,
-  TypedClass
+  ModulesRecord,
+  TypedClass,
+  noop,
 } from "@proto-kit/common";
 import { PublicKey, SmartContract } from "o1js";
 import { injectable } from "tsyringe";
@@ -43,7 +44,7 @@ export type MandatorySettlementModulesRecord = {
 @injectable()
 export class SettlementContractModule<
     SettlementModules extends SettlementModulesRecord &
-      MandatorySettlementModulesRecord
+      MandatorySettlementModulesRecord,
   >
   extends ModuleContainer<SettlementModules>
   implements ProtocolModule<unknown>
@@ -54,7 +55,7 @@ export class SettlementContractModule<
 
   public static from<
     SettlementModules extends SettlementModulesRecord &
-      MandatorySettlementModulesRecord
+      MandatorySettlementModulesRecord,
   >(
     modules: SettlementModules
   ): TypedClass<SettlementContractModule<SettlementModules>> {
@@ -84,16 +85,18 @@ export class SettlementContractModule<
     super.create(childContainerProvider);
   }
 
-  // private assertIsKeyofModules
+  public async start() {
+    noop();
+  }
 
   public getContractClasses(): {
     settlement: SmartContractClassFromInterface<SettlementContractType>;
     dispatch: SmartContractClassFromInterface<DispatchContractType>;
   } {
-    const settlementContractKey = "SettlementContract"
-    const dispatchContractKey = "DispatchContract"
-    this.assertIsValidModuleName(settlementContractKey)
-    this.assertIsValidModuleName(dispatchContractKey)
+    const settlementContractKey = "SettlementContract";
+    const dispatchContractKey = "DispatchContract";
+    this.assertIsValidModuleName(settlementContractKey);
+    this.assertIsValidModuleName(dispatchContractKey);
 
     const settlementModule = this.resolve(settlementContractKey);
     const dispatchModule = this.resolve(dispatchContractKey);
@@ -116,7 +119,9 @@ export class SettlementContractModule<
   } {
     const { dispatch, settlement } = this.getContractClasses();
 
+    // eslint-disable-next-line new-cap
     const dispatchInstance = new dispatch(addresses.dispatch);
+    // eslint-disable-next-line new-cap
     const settlementInstance = new settlement(addresses.settlement);
 
     return {

package/src/settlement/contracts/DispatchSmartContract.ts

@@ -26,8 +26,8 @@ export interface DispatchContractType {
   updateMessagesHash: (
     executedMessagesHash: Field,
     newPromisedMessagesHash: Field
-  ) => void;
-  initialize: (settlementContract: PublicKey) => void;
+  ) => Promise<void>;
+  initialize: (settlementContract: PublicKey) => Promise<void>;
 
   promisedMessagesHash: State<Field>;
 }
@@ -48,29 +48,30 @@ export class DispatchSmartContract
   @state(PublicKey) public settlementContract = State<PublicKey>();
 
   @method
-  public updateMessagesHash(
+  public async updateMessagesHash(
     executedMessagesHash: Field,
     newPromisedMessagesHash: Field
   ) {
-    const promisedMessagesHash = this.promisedMessagesHash.getAndAssertEquals();
-    this.honoredMessagesHash.getAndAssertEquals();
+    const promisedMessagesHash =
+      this.promisedMessagesHash.getAndRequireEquals();
+    this.honoredMessagesHash.getAndRequireEquals();
 
     executedMessagesHash.assertEquals(promisedMessagesHash);
 
     this.honoredMessagesHash.set(executedMessagesHash);
 
     // Assert and apply new promisedMessagesHash
-    this.self.account.actionState.assertEquals(newPromisedMessagesHash);
+    this.self.account.actionState.requireEquals(newPromisedMessagesHash);
     this.promisedMessagesHash.set(newPromisedMessagesHash);
   }
 
   @method
-  public initialize(settlementContract: PublicKey) {
-    this.promisedMessagesHash.getAndAssertEquals().assertEquals(Field(0));
-    this.honoredMessagesHash.getAndAssertEquals().assertEquals(Field(0));
+  public async initialize(settlementContract: PublicKey) {
+    this.promisedMessagesHash.getAndRequireEquals().assertEquals(Field(0));
+    this.honoredMessagesHash.getAndRequireEquals().assertEquals(Field(0));
     this.settlementContract
-      .getAndAssertEquals()
-      .assertEquals(PublicKey.empty());
+      .getAndRequireEquals()
+      .assertEquals(PublicKey.empty<typeof PublicKey>());
 
     this.promisedMessagesHash.set(ACTIONS_EMPTY_HASH);
     this.honoredMessagesHash.set(ACTIONS_EMPTY_HASH);
@@ -107,12 +108,12 @@ export class DispatchSmartContract
   }
 
   @method
-  public deposit(amount: UInt64) {
+  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;
+    const sender = this.sender.getUnconstrained();
 
-    const settlementContract = this.settlementContract.getAndAssertEquals();
+    const settlementContract = this.settlementContract.getAndRequireEquals();
 
     // Credit the amount to the settlement contract
     const balanceAU = AccountUpdate.create(settlementContract);

package/src/settlement/contracts/SettlementContractProtocolModule.ts

@@ -46,12 +46,14 @@ export class SettlementContractProtocolModule extends ContractModule<
   ): SmartContractClassFromInterface<SettlementContractType> {
     const { hooks, config } = this;
 
-    const withdrawalStatePathSplit = this.config.withdrawalStatePath.split(
-      "."
-    ) as [string, string];
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const withdrawalStatePathSplit = config.withdrawalStatePath.split(".") as [
+      string,
+      string,
+    ];
 
     const escapeHatchSlotsInterval =
-      this.config.escapeHatchSlotsInterval ?? DEFAULT_ESCAPE_HATCH;
+      config.escapeHatchSlotsInterval ?? DEFAULT_ESCAPE_HATCH;
 
     SettlementSmartContract.args = {
       DispatchContract: dispatchContract,

package/src/settlement/contracts/SettlementSmartContract.ts

@@ -1,4 +1,9 @@
-import { prefixToField, RollupMerkleTree, TypedClass } from "@proto-kit/common";
+import {
+  prefixToField,
+  RollupMerkleTree,
+  TypedClass,
+  mapSequential,
+} from "@proto-kit/common";
 import {
   AccountUpdate,
   Bool,
@@ -16,7 +21,10 @@ import {
   TokenId,
   UInt32,
   UInt64,
+  TokenContract,
+  AccountUpdateForest,
 } from "o1js";
+
 import { NetworkState } from "../../model/network/NetworkState";
 import { Path } from "../../model/Path";
 import { BlockHashMerkleTree } from "../../prover/block/accummulators/BlockHashMerkleTree";
@@ -37,6 +45,8 @@ import {
 
 import { DispatchContractType } from "./DispatchSmartContract";
 
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+
 export class LazyBlockProof extends Proof<
   BlockProverPublicInput,
   BlockProverPublicOutput
@@ -51,7 +61,10 @@ export class LazyBlockProof extends Proof<
 }
 
 export interface SettlementContractType {
-  initialize: (sequencer: PublicKey, dispatchContract: PublicKey) => void;
+  initialize: (
+    sequencer: PublicKey,
+    dispatchContract: PublicKey
+  ) => Promise<void>;
   settle: (
     blockProof: LazyBlockProof,
     signature: Signature,
@@ -60,16 +73,18 @@ export interface SettlementContractType {
     inputNetworkState: NetworkState,
     outputNetworkState: NetworkState,
     newPromisedMessagesHash: Field
-  ) => void;
-  rollupOutgoingMessages: (batch: OutgoingMessageArgumentBatch) => void;
-  redeem: (additionUpdate: AccountUpdate) => void;
+  ) => Promise<void>;
+  rollupOutgoingMessages: (
+    batch: OutgoingMessageArgumentBatch
+  ) => 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 SmartContract
+  extends TokenContract
   implements SettlementContractType
 {
   // This pattern of injecting args into a smartcontract is currently the only
@@ -92,13 +107,17 @@ export class SettlementSmartContract
 
   @state(Field) public outgoingMessageCursor = State<Field>();
 
+  @method async approveBase(forest: AccountUpdateForest) {
+    this.checkZeroBalanceChange(forest);
+  }
+
   @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));
+  public async initialize(sequencer: PublicKey, dispatchContract: PublicKey) {
+    this.sequencerKey.getAndRequireEquals().assertEquals(Field(0));
+    this.stateRoot.getAndRequireEquals().assertEquals(Field(0));
+    this.blockHashRoot.getAndRequireEquals().assertEquals(Field(0));
+    this.networkStateHash.getAndRequireEquals().assertEquals(Field(0));
+    this.dispatchContractAddressX.getAndRequireEquals().assertEquals(Field(0));
 
     this.sequencerKey.set(sequencer.x);
     this.stateRoot.set(Field(RollupMerkleTree.EMPTY_ROOT));
@@ -106,12 +125,12 @@ export class SettlementSmartContract
     this.networkStateHash.set(NetworkState.empty().hash());
     this.dispatchContractAddressX.set(dispatchContract.x);
 
-    const DispatchContract = SettlementSmartContract.args.DispatchContract;
-    new DispatchContract(dispatchContract).initialize(this.address);
+    const { DispatchContract } = SettlementSmartContract.args;
+    await new DispatchContract(dispatchContract).initialize(this.address);
   }
 
   @method
-  public settle(
+  public async settle(
     blockProof: LazyBlockProof,
     signature: Signature,
     dispatchContractAddress: PublicKey,
@@ -124,14 +143,14 @@ export class SettlementSmartContract
     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 stateRoot = this.stateRoot.getAndRequireEquals();
+    const networkStateHash = this.networkStateHash.getAndRequireEquals();
+    const blockHashRoot = this.blockHashRoot.getAndRequireEquals();
+    const sequencerKey = this.sequencerKey.getAndRequireEquals();
     const lastSettlementL1Block =
-      this.lastSettlementL1Block.getAndAssertEquals();
+      this.lastSettlementL1Block.getAndRequireEquals();
     const onChainDispatchContractAddressX =
-      this.dispatchContractAddressX.getAndAssertEquals();
+      this.dispatchContractAddressX.getAndRequireEquals();
 
     onChainDispatchContractAddressX.assertEquals(
       dispatchContractAddress.x,
@@ -149,7 +168,7 @@ export class SettlementSmartContract
 
     // Get block height and use the lower bound for all ops
     const minBlockIncluded = this.network.globalSlotSinceGenesis.get();
-    this.network.globalSlotSinceGenesis.assertBetween(
+    this.network.globalSlotSinceGenesis.requireBetween(
       minBlockIncluded,
       // 5 because that is the length the newPromisedMessagesHash will be valid
       minBlockIncluded.add(4)
@@ -209,8 +228,8 @@ export class SettlementSmartContract
       toNetworkState: outputNetworkState,
       currentL1Block: minBlockIncluded,
     };
-    hooks.forEach((hook) => {
-      hook.beforeSettlement(this, inputs);
+    await mapSequential(hooks, async (hook) => {
+      await hook.beforeSettlement(this, inputs);
     });
 
     // Apply blockProof
@@ -245,7 +264,7 @@ export class SettlementSmartContract
     // 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(
+    await dispatchContract.updateMessagesHash(
       promisedMessagesHash,
       newPromisedMessagesHash
     );
@@ -254,9 +273,9 @@ export class SettlementSmartContract
   }
 
   @method
-  public rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch) {
-    let counter = this.outgoingMessageCursor.getAndAssertEquals();
-    const stateRoot = this.stateRoot.getAndAssertEquals();
+  public async rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch) {
+    let counter = this.outgoingMessageCursor.getAndRequireEquals();
+    const stateRoot = this.stateRoot.getAndRequireEquals();
 
     const [withdrawalModule, withdrawalStateName] =
       SettlementSmartContract.args.withdrawalStatePath;
@@ -282,13 +301,13 @@ export class SettlementSmartContract
       const { address, amount } = args.value;
       const isDummy = address.equals(this.address);
 
-      const tokenAu = this.token.mint({ address, amount });
-      const isNewAccount = tokenAu.account.isNew.getAndAssertEquals();
+      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.accountCreationFee().toConstant(),
+            Mina.getNetworkConstants().accountCreationFee.toConstant(),
             UInt64.zero
           )
         );
@@ -300,13 +319,13 @@ export class SettlementSmartContract
       counter = counter.add(Provable.if(isDummy, Field(0), Field(1)));
     }
 
-    this.balance.subInPlace(UInt64.from(accountCreationFeePaid));
+    this.balance.subInPlace(UInt64.Unsafe.fromField(accountCreationFeePaid));
 
     this.outgoingMessageCursor.set(counter);
   }
 
   @method
-  public redeem(additionUpdate: AccountUpdate) {
+  public async redeem(additionUpdate: AccountUpdate) {
     additionUpdate.body.tokenId.assertEquals(
       TokenId.default,
       "Tokenid not default token"
@@ -317,7 +336,7 @@ export class SettlementSmartContract
     const amount = additionUpdate.body.balanceChange.magnitude;
 
     // Burn tokens
-    this.token.burn({
+    this.internal.burn({
       address: additionUpdate.publicKey,
       amount,
     });
@@ -327,3 +346,5 @@ export class SettlementSmartContract
     this.balance.subInPlace(amount);
   }
 }
+
+/* eslint-enable @typescript-eslint/lines-between-class-members */

package/src/settlement/messages/OutgoingMessageArgument.ts

@@ -1,5 +1,6 @@
 import { Bool, Provable, Struct } from "o1js";
 import { RollupMerkleTreeWitness } from "@proto-kit/common";
+
 import { Withdrawal } from "./Withdrawal";
 
 export const OUTGOING_MESSAGE_BATCH_SIZE = 1;

package/src/settlement/modularity/ProvableSettlementHook.ts

@@ -1,9 +1,8 @@
 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 { BlockProof } from "../../prover/block/BlockProver";
 import type { SettlementSmartContract } from "../contracts/SettlementSmartContract";
 
 export type SettlementStateRecord = {
@@ -25,10 +24,10 @@ export type SettlementHookInputs = {
 };
 
 export abstract class ProvableSettlementHook<
-  Config
+  Config,
 > extends ProtocolModule<Config> {
   public abstract beforeSettlement(
     smartContract: SettlementSmartContract,
     inputs: SettlementHookInputs
-  ): void;
+  ): Promise<void>;
 }

package/src/settlement/modules/NetworkStateSettlementModule.ts

@@ -10,8 +10,9 @@ type NetworkStateSettlementModuleConfig = {
   blocksPerL1Block: UInt64;
 };
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
 export class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
-  public beforeSettlement(
+  public async beforeSettlement(
     smartContract: SettlementSmartContract,
     {
       blockProof,
@@ -20,7 +21,7 @@ export class NetworkStateSettlementModule extends ProvableSettlementHook<Network
       contractState,
       currentL1Block,
     }: SettlementHookInputs
-  ): void {
+  ) {
     const { lastSettlementL1Block } = contractState;
 
     const blocksPerL1Block = this.config.blocksPerL1Block.toConstant();
@@ -37,3 +38,5 @@ export class NetworkStateSettlementModule extends ProvableSettlementHook<Network
     // TODO Check within bounds efficiently
   }
 }
+
+/* eslint-enable @typescript-eslint/no-unused-vars */

package/src/state/State.ts

@@ -1,5 +1,5 @@
 import { Mixin } from "ts-mixer";
-import { Bool, Field, Provable, type FlexibleProvablePure } from "o1js";
+import { Bool, Field, Provable, type FlexibleProvablePure, Struct } from "o1js";
 import { container } from "tsyringe";
 import { dummyValue } from "@proto-kit/common";
 
@@ -54,6 +54,11 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
     super();
   }
 
+  private stateType = class StateType extends Struct({
+    value: this.valueType,
+    isSome: Bool,
+  }) {};
+
   /**
    * Returns the state that is currently the current state tree
    * value: The value-fields, or if not state was found, dummy values
@@ -61,7 +66,7 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    * (Basically, whether the value-fields are dummy values or actual values
    * @private
    */
-  private getState(): { value: Value; isSome: Bool } {
+  private async getState(): Promise<{ value: Value; isSome: Bool }> {
     this.hasStateServiceOrFail();
     this.hasPathOrFail();
 
@@ -71,6 +76,7 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
       .resolve(RuntimeMethodExecutionContext)
       .current().result;
 
+    // TODO Use Stateservice for this
     // First try to find a match inside already created stateTransitions
     let previousMutatingTransitions: StateTransition<any>[] = [];
     previousMutatingTransitions = stateTransitions.filter((transition) =>
@@ -89,7 +95,7 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
     }
 
     // If the value is still undefined, look it up in the stateService
-    const fields = stateServiceProvider.stateService.get(path);
+    const fields = await stateServiceProvider.stateService.get(path);
     if (fields) {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       value = valueType.fromFields(fields) as Value;
@@ -107,12 +113,13 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    *
    * @returns Optional value of the current state
    */
-  private witnessFromState() {
+  private async witnessFromState() {
     // get the value from storage, or return a dummy value instead
-    const value = Provable.witness(this.valueType, () => this.getState().value);
-
-    // check if the value exists in the storage or not
-    const isSome = Provable.witness(Bool, () => this.getState().isSome);
+    // also check if the value exists in the storage or not
+    const { value, isSome } = await Provable.witnessAsync(
+      this.stateType,
+      async () => await this.getState()
+    );
 
     return Option.from(isSome, value, this.valueType);
   }
@@ -123,8 +130,8 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    *
    * @returns Option representation of the current state.
    */
-  public get(): Option<Value> {
-    const option = this.witnessFromState();
+  public async get(): Promise<Option<Value>> {
+    const option = await this.witnessFromState();
 
     this.hasPathOrFail();
 
@@ -148,9 +155,9 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    *
    * @param value - Value to be set as the current state
    */
-  public set(value: Value) {
+  public async set(value: Value) {
     // link the transition to the current state
-    const fromOption = this.witnessFromState();
+    const fromOption = await this.witnessFromState();
     const toOption = Option.fromValue(value, this.valueType);
 
     this.hasPathOrFail();