@proto-kit/protocol 0.1.1-develop.165 → 0.1.1-develop.1665

package/dist/model/StateTransitionProvableBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG/D;;;GAGG;AACH,qBAAa,4BAA6B,SAAQ,iCAKhD;IACA,OAAO;WAIO,eAAe,CAC3B,WAAW,EAAE,uBAAuB,EAAE,GACrC,4BAA4B;CAShC"}
+{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAA2B,MAAM,MAAM,CAAC;AACrD,OAAO,EAAS,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAInE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,qBAAa,mBAAmB;IAC9B,gBAAuB,OAAO,KAAK;IAInC,gBAAuB,aAAa,KAAK;IAEzC,gBAAuB,iBAAiB,KAAK;CAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,gCAE/C;IACA,WAAkB,OAAO,IAAI,2BAA2B,CAEvD;IAED,WAAkB,aAAa,IAAI,2BAA2B,CAE7D;IAED,WAAkB,iBAAiB,IAAI,2BAA2B,CAEjE;IAED,OAAO,CAAC,MAAM,CAAC,IAAI;IAMZ,SAAS;IAOT,SAAS;CAGjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAKtC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,4BAA6B,SAAQ,iCAIhD;WACc,KAAK,IAAI,4BAA4B;CAOpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;;;;;GAMG;AACH,qBAAa,4BAA6B,SAAQ,iCAKhD;WACc,WAAW,CACvB,OAAO,EAAE;QACP,gBAAgB,EAAE,uBAAuB,EAAE,CAAC;QAC5C,OAAO,EAAE,IAAI,CAAC;QACd,WAAW,EAAE,IAAI,CAAC;KACnB,EAAE,GACF,4BAA4B,EAAE;CAwClC"}

package/dist/model/StateTransitionProvableBatch.js

@@ -1,21 +1,98 @@
-import { Circuit, Struct } from "snarkyjs";
-import { ProvableStateTransition } from "./StateTransition.js";
+import { Bool, Field, Provable, Struct } from "o1js";
+import { batch, LinkedMerkleTreeWitness } from "@proto-kit/common";
 import { constants } from "../Constants";
+import { ProvableStateTransition } from "./StateTransition.js";
+export class StateTransitionType {
+}
+StateTransitionType.nothing = 2;
+// The reason these are 0 and 1 is to efficiently check
+// x in [inside, closing] in-circuit via the boolean trick
+StateTransitionType.closeAndApply = 1;
+StateTransitionType.closeAndThrowAway = 0;
+/**
+ * STType is encoding both the type and whether it should be accumulated or not in one field
+ */
+export class ProvableStateTransitionType extends Struct({
+    type: Field,
+}) {
+    static get nothing() {
+        return this.from(StateTransitionType.nothing);
+    }
+    static get closeAndApply() {
+        return this.from(StateTransitionType.closeAndApply);
+    }
+    static get closeAndThrowAway() {
+        return this.from(StateTransitionType.closeAndThrowAway);
+    }
+    static from(constant) {
+        return new ProvableStateTransitionType({
+            type: Field(constant),
+        });
+    }
+    isClosing() {
+        const { type } = this;
+        // check if base is 0 or 1
+        // 0^2 == 0 && 1^2 == 1
+        return type.mul(type).equals(type);
+    }
+    isNothing() {
+        return this.type.equals(ProvableStateTransitionType.nothing.type);
+    }
+}
+export class MerkleWitnessBatch extends Struct({
+    witnesses: Provable.Array(LinkedMerkleTreeWitness, constants.stateTransitionProverBatchSize),
+}) {
+}
+export class ProvableStateTransitionEntry extends Struct({
+    stateTransition: ProvableStateTransition,
+    type: ProvableStateTransitionType,
+    witnessRoot: Bool,
+}) {
+    static dummy() {
+        return {
+            stateTransition: ProvableStateTransition.dummy(),
+            type: ProvableStateTransitionType.nothing,
+            witnessRoot: Bool(false),
+        };
+    }
+}
 /**
  * A Batch of StateTransitions to be consumed by the StateTransitionProver
  * to prove multiple STs at once
+ *
+ * The batch is formed as an array fo ProvableSTEntries, which have a type and
+ * witnessesRoot flag attached to them.
  */
 export class StateTransitionProvableBatch extends Struct({
-    batch: Circuit.array(ProvableStateTransition, constants.stateTransitionProverBatchSize),
+    batch: Provable.Array(ProvableStateTransitionEntry, constants.stateTransitionProverBatchSize),
 }) {
-    constructor(object) {
-        super(object);
-    }
-    static fromTransitions(transitions) {
-        const array = transitions.slice();
-        while (array.length < constants.stateTransitionProverBatchSize) {
-            array.push(ProvableStateTransition.dummy());
+    static fromBatches(batches) {
+        const flattened = [];
+        for (const stBatch of batches) {
+            const entries = stBatch.stateTransitions.map((stateTransition, j, sts) => {
+                return {
+                    stateTransition,
+                    type: 
+                    // eslint-disable-next-line no-nested-ternary
+                    j === sts.length - 1
+                        ? stBatch.applied.toBoolean()
+                            ? ProvableStateTransitionType.closeAndApply
+                            : ProvableStateTransitionType.closeAndThrowAway
+                        : ProvableStateTransitionType.nothing,
+                    witnessRoot: Bool(false),
+                };
+            });
+            flattened.push(...entries);
+            if (stBatch.witnessRoot.toBoolean() && flattened.length > 0) {
+                flattened.at(-1).witnessRoot = Bool(true);
+            }
         }
-        return new StateTransitionProvableBatch({ batch: array });
+        const values = batch(flattened, constants.stateTransitionProverBatchSize, () => ProvableStateTransitionEntry.dummy());
+        return values.map((stBatch) => {
+            return new StateTransitionProvableBatch({
+                batch: stBatch,
+            });
+        });
     }
 }
+//# sourceMappingURL=StateTransitionProvableBatch.js.map

package/dist/model/StateTransitionProvableBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionProvableBatch.js","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"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"}

package/dist/model/network/NetworkState.d.ts

@@ -1,18 +1,29 @@
-import { Field, UInt64 } from "snarkyjs";
+import { Field, UInt64 } from "o1js";
 declare const CurrentBlock_base: (new (value: {
     height: UInt64;
 }) => {
     height: UInt64;
 }) & {
     _isStruct: true;
-} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
     height: UInt64;
-}> & {
+}, {
+    height: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        height: UInt64;
+    };
+} & {
+    fromValue: (value: {
+        height: bigint | UInt64;
+    }) => {
+        height: UInt64;
+    };
     toInput: (x: {
         height: UInt64;
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
     };
     toJSON: (x: {
         height: UInt64;
@@ -24,41 +35,126 @@ declare const CurrentBlock_base: (new (value: {
     }) => {
         height: UInt64;
     };
+    empty: () => {
+        height: UInt64;
+    };
 };
 export declare class CurrentBlock extends CurrentBlock_base {
 }
+declare const PreviousBlock_base: (new (value: {
+    rootHash: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    rootHash: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    rootHash: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    rootHash: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        rootHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        rootHash: string;
+    };
+    fromJSON: (x: {
+        rootHash: string;
+    }) => {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class PreviousBlock extends PreviousBlock_base {
+}
 declare const NetworkState_base: (new (value: {
     block: CurrentBlock;
+    previous: PreviousBlock;
 }) => {
     block: CurrentBlock;
+    previous: PreviousBlock;
 }) & {
     _isStruct: true;
-} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
     block: CurrentBlock;
-}> & {
+    previous: PreviousBlock;
+}, {
+    block: {
+        height: bigint;
+    };
+    previous: {
+        rootHash: bigint;
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        block: CurrentBlock;
+        previous: PreviousBlock;
+    };
+} & {
+    fromValue: (value: {
+        block: CurrentBlock | {
+            height: bigint | UInt64;
+        };
+        previous: PreviousBlock | {
+            rootHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+    }) => {
+        block: CurrentBlock;
+        previous: PreviousBlock;
+    };
     toInput: (x: {
         block: CurrentBlock;
+        previous: PreviousBlock;
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
     };
     toJSON: (x: {
         block: CurrentBlock;
+        previous: PreviousBlock;
     }) => {
         block: {
             height: string;
         };
+        previous: {
+            rootHash: string;
+        };
     };
     fromJSON: (x: {
         block: {
             height: string;
         };
+        previous: {
+            rootHash: string;
+        };
     }) => {
         block: CurrentBlock;
+        previous: PreviousBlock;
+    };
+    empty: () => {
+        block: CurrentBlock;
+        previous: PreviousBlock;
     };
 };
 export declare class NetworkState extends NetworkState_base {
     hash(): Field;
+    static empty(): NetworkState;
 }
 export {};
 //# sourceMappingURL=NetworkState.d.ts.map

package/dist/model/network/NetworkState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkState.d.ts","sourceRoot":"","sources":["../../../src/model/network/NetworkState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3D,qBAAa,YAAa,SAAQ,iBAEhC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAEhC;IACO,IAAI,IAAI,KAAK;CAKrB"}
+{"version":3,"file":"NetworkState.d.ts","sourceRoot":"","sources":["../../../src/model/network/NetworkState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,MAAM,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvD,qBAAa,YAAa,SAAQ,iBAEhC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,aAAc,SAAQ,kBAEjC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAGhC;IACO,IAAI,IAAI,KAAK;WAON,KAAK;CAUpB"}

package/dist/model/network/NetworkState.js

@@ -1,14 +1,32 @@
-import { Poseidon, Struct, UInt64 } from "snarkyjs";
+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,
 }) {
     hash() {
         return Poseidon.hash([
-            ...CurrentBlock.toFields(this.block)
+            ...CurrentBlock.toFields(this.block),
+            ...PreviousBlock.toFields(this.previous),
         ]);
     }
+    static empty() {
+        return new NetworkState({
+            block: {
+                height: UInt64.zero,
+            },
+            previous: {
+                rootHash: Field(RollupMerkleTree.EMPTY_ROOT),
+            },
+        });
+    }
 }
+//# sourceMappingURL=NetworkState.js.map

package/dist/model/network/NetworkState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkState.js","sourceRoot":"","sources":["../../../src/model/network/NetworkState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,OAAO,YAAa,SAAQ,MAAM,CAAC;IACvC,MAAM,EAAE,MAAM;CACf,CAAC;CAAG;AAEL,MAAM,OAAO,aAAc,SAAQ,MAAM,CAAC;IACxC,QAAQ,EAAE,KAAK;CAChB,CAAC;CAAG;AAEL,MAAM,OAAO,YAAa,SAAQ,MAAM,CAAC;IACvC,KAAK,EAAE,YAAY;IACnB,QAAQ,EAAE,aAAa;CACxB,CAAC;IACO,IAAI;QACT,OAAO,QAAQ,CAAC,IAAI,CAAC;YACnB,GAAG,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;YACpC,GAAG,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;SACzC,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,KAAK;QACjB,OAAO,IAAI,YAAY,CAAC;YACtB,KAAK,EAAE;gBACL,MAAM,EAAE,MAAM,CAAC,IAAI;aACpB;YACD,QAAQ,EAAE;gBACR,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,UAAU,CAAC;aAC7C;SACF,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/model/transaction/RuntimeTransaction.d.ts

@@ -1,45 +1,99 @@
-import { Field, PublicKey, UInt64 } from "snarkyjs";
-import { ProtocolTransaction } from "./ProtocolTransaction";
+import { Bool, Field, PublicKey, UInt64 } from "o1js";
+import { PublicKeyOption, UInt64Option } from "./ValueOption";
 declare const RuntimeTransaction_base: (new (value: {
-    nonce: UInt64;
-    sender: PublicKey;
-    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    methodId: import("o1js/dist/node/lib/provable/field").Field;
+    argsHash: import("o1js/dist/node/lib/provable/field").Field;
+    nonce: UInt64Option;
+    sender: PublicKeyOption;
 }) => {
-    nonce: UInt64;
-    sender: PublicKey;
-    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    methodId: import("o1js/dist/node/lib/provable/field").Field;
+    argsHash: import("o1js/dist/node/lib/provable/field").Field;
+    nonce: UInt64Option;
+    sender: PublicKeyOption;
 }) & {
     _isStruct: true;
-} & import("snarkyjs/dist/node/snarky").ProvablePure<{
-    nonce: UInt64;
-    sender: PublicKey;
-    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+} & import("o1js/dist/node/lib/provable/provable").Provable<{
+    methodId: import("o1js/dist/node/lib/provable/field").Field;
+    argsHash: import("o1js/dist/node/lib/provable/field").Field;
+    nonce: UInt64Option;
+    sender: PublicKeyOption;
+}, {
+    methodId: bigint;
+    argsHash: bigint;
+    nonce: {
+        isSome: boolean;
+        value: any;
+    };
+    sender: {
+        isSome: boolean;
+        value: any;
+    };
 }> & {
+    fromValue: (value: {
+        methodId: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        argsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        nonce: UInt64Option | {
+            isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            value: any;
+        };
+        sender: PublicKeyOption | {
+            isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            value: any;
+        };
+    }) => {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        argsHash: import("o1js/dist/node/lib/provable/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
+    };
     toInput: (x: {
-        nonce: UInt64;
-        sender: PublicKey;
-        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        argsHash: import("o1js/dist/node/lib/provable/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
     };
     toJSON: (x: {
-        nonce: UInt64;
-        sender: PublicKey;
-        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        argsHash: import("o1js/dist/node/lib/provable/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
     }) => {
-        nonce: string;
-        sender: string;
+        methodId: string;
         argsHash: string;
+        nonce: {
+            isSome: boolean;
+            value: any;
+        };
+        sender: {
+            isSome: boolean;
+            value: any;
+        };
     };
     fromJSON: (x: {
-        nonce: string;
-        sender: string;
+        methodId: string;
         argsHash: string;
+        nonce: {
+            isSome: boolean;
+            value: any;
+        };
+        sender: {
+            isSome: boolean;
+            value: any;
+        };
     }) => {
-        nonce: UInt64;
-        sender: PublicKey;
-        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        argsHash: import("o1js/dist/node/lib/provable/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
+    };
+    empty: () => {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        argsHash: import("o1js/dist/node/lib/provable/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
     };
 };
 /**
@@ -48,7 +102,21 @@ declare const RuntimeTransaction_base: (new (value: {
  * For example, we don't want to expose the signature or args as fields.
  */
 export declare class RuntimeTransaction extends RuntimeTransaction_base {
-    static fromProtocolTransaction({ nonce, sender, argsHash, }: ProtocolTransaction): RuntimeTransaction;
+    static fromTransaction(input: {
+        methodId: Field;
+        argsHash: Field;
+        nonce: UInt64;
+        sender: PublicKey;
+    }): RuntimeTransaction;
+    static fromMessage({ methodId, argsHash, }: {
+        methodId: Field;
+        argsHash: Field;
+    }): RuntimeTransaction;
+    static dummyTransaction(): RuntimeTransaction;
+    assertTransactionType(isMessage: Bool): void;
+    isDummy(): Bool;
+    hashData(): Field[];
+    static fromHashData(fields: Field[]): RuntimeTransaction;
     hash(): Field;
 }
 export {};

package/dist/model/transaction/RuntimeTransaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuntimeTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/RuntimeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,SAAS,EAAU,MAAM,EAAE,MAAM,UAAU,CAAC;AAEtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,uBAItC;WACc,uBAAuB,CAAC,EACpC,KAAK,EACL,MAAM,EACN,QAAQ,GACT,EAAE,mBAAmB,GAAG,kBAAkB;IAQpC,IAAI,IAAI,KAAK;CAOrB"}
+{"version":3,"file":"RuntimeTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/RuntimeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAY,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;AAGxE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,uBAKtC;WACc,eAAe,CAAC,KAAK,EAAE;QACnC,QAAQ,EAAE,KAAK,CAAC;QAChB,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,SAAS,CAAC;KACnB;WASa,WAAW,CAAC,EACxB,QAAQ,EACR,QAAQ,GACT,EAAE;QACD,QAAQ,EAAE,KAAK,CAAC;QAChB,QAAQ,EAAE,KAAK,CAAC;KACjB;WASa,gBAAgB,IAAI,kBAAkB;IAe7C,qBAAqB,CAAC,SAAS,EAAE,IAAI;IAerC,OAAO,IAAI,IAAI;IAIf,QAAQ,IAAI,KAAK,EAAE;WASZ,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE;IAiBnC,IAAI,IAAI,KAAK;CAGrB"}

package/dist/model/transaction/RuntimeTransaction.js

@@ -1,26 +1,90 @@
-import { Field, Poseidon, PublicKey, Struct, UInt64 } from "snarkyjs";
+import { Bool, Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
+import { EMPTY_PUBLICKEY, EMPTY_PUBLICKEY_X } from "@proto-kit/common";
+import { PublicKeyOption, UInt64Option } from "./ValueOption";
 /**
  * This struct is used to expose transaction information to the runtime method
  * execution. This class has not all data included in transactions on purpose.
  * For example, we don't want to expose the signature or args as fields.
  */
 export class RuntimeTransaction extends Struct({
-    nonce: UInt64,
-    sender: PublicKey,
+    methodId: Field,
     argsHash: Field,
+    nonce: UInt64Option,
+    sender: PublicKeyOption,
 }) {
-    static fromProtocolTransaction({ nonce, sender, argsHash, }) {
+    static fromTransaction(input) {
         return new RuntimeTransaction({
-            nonce,
-            sender,
+            methodId: input.methodId,
+            argsHash: input.argsHash,
+            nonce: UInt64Option.fromSome(input.nonce),
+            sender: PublicKeyOption.fromSome(input.sender),
+        });
+    }
+    static fromMessage({ methodId, argsHash, }) {
+        return new RuntimeTransaction({
+            methodId,
             argsHash,
+            nonce: UInt64Option.none(UInt64.zero),
+            sender: PublicKeyOption.none(EMPTY_PUBLICKEY),
         });
     }
-    hash() {
-        return Poseidon.hash([
-            ...this.nonce.toFields(),
-            ...this.sender.toFields(),
+    static dummyTransaction() {
+        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),
+        });
+    }
+    assertTransactionType(isMessage) {
+        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");
+    }
+    isDummy() {
+        return this.methodId.equals(0);
+    }
+    hashData() {
+        return [
+            this.methodId,
+            ...this.sender.value.toFields(),
+            ...this.nonce.value.toFields(),
             this.argsHash,
-        ]);
+        ];
+    }
+    static fromHashData(fields) {
+        // 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],
+        });
+    }
+    hash() {
+        return Poseidon.hash(this.hashData());
     }
 }
+//# sourceMappingURL=RuntimeTransaction.js.map

package/dist/model/transaction/RuntimeTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeTransaction.js","sourceRoot":"","sources":["../../../src/model/transaction/RuntimeTransaction.ts"],"names":[],"mappings":"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"}