@proto-kit/protocol 0.1.1-develop.1086

package/dist/model/StateTransitionProvableBatch.d.ts

@@ -0,0 +1,172 @@
+import { Bool } from "o1js";
+import { ProvableStateTransition } from "./StateTransition.js";
+export declare class StateTransitionType {
+    static readonly normal = true;
+    static readonly protocol = false;
+    static isNormal(type: boolean): boolean;
+    static isProtocol(type: boolean): boolean;
+}
+declare const ProvableStateTransitionType_base: (new (value: {
+    type: import("o1js/dist/node/lib/provable/bool").Bool;
+}) => {
+    type: import("o1js/dist/node/lib/provable/bool").Bool;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    type: import("o1js/dist/node/lib/provable/bool").Bool;
+}, {
+    type: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+} & {
+    fromValue: (value: {
+        type: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    toInput: (x: {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        type: boolean;
+    };
+    fromJSON: (x: {
+        type: boolean;
+    }) => {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    empty: () => {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+};
+export declare class ProvableStateTransitionType extends ProvableStateTransitionType_base {
+    static get normal(): ProvableStateTransitionType;
+    static get protocol(): ProvableStateTransitionType;
+    isNormal(): Bool;
+    isProtocol(): Bool;
+}
+declare const StateTransitionProvableBatch_base: (new (value: {
+    batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
+}) => {
+    batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
+}, {
+    batch: {
+        path: bigint;
+        from: {
+            isSome: boolean;
+            value: bigint;
+        };
+        to: {
+            isSome: boolean;
+            value: bigint;
+        };
+    }[];
+    transitionTypes: {
+        type: boolean;
+    }[];
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+    };
+} & {
+    fromValue: (value: {
+        batch: ProvableStateTransition[] | {
+            path: bigint;
+            from: {
+                isSome: boolean;
+                value: bigint;
+            };
+            to: {
+                isSome: boolean;
+                value: bigint;
+            };
+        }[];
+        transitionTypes: ProvableStateTransitionType[] | {
+            type: boolean;
+        }[];
+    }) => {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+    };
+    toInput: (x: {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+    }) => {
+        batch: {
+            path: string;
+            from: {
+                isSome: boolean;
+                value: string;
+            };
+            to: {
+                isSome: boolean;
+                value: string;
+            };
+        }[];
+        transitionTypes: {
+            type: boolean;
+        }[];
+    };
+    fromJSON: (x: {
+        batch: {
+            path: string;
+            from: {
+                isSome: boolean;
+                value: string;
+            };
+            to: {
+                isSome: boolean;
+                value: string;
+            };
+        }[];
+        transitionTypes: {
+            type: boolean;
+        }[];
+    }) => {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+    };
+    empty: () => {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+    };
+};
+/**
+ * A Batch of StateTransitions to be consumed by the StateTransitionProver
+ * to prove multiple STs at once
+ *
+ * transitionType:
+ * true == normal ST, false == protocol ST
+ */
+export declare class StateTransitionProvableBatch extends StateTransitionProvableBatch_base {
+    static fromMappings(transitions: {
+        transition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+    }[]): StateTransitionProvableBatch;
+    static fromTransitions(transitions: ProvableStateTransition[], protocolTransitions: ProvableStateTransition[]): StateTransitionProvableBatch;
+    private constructor();
+}
+export {};
+//# sourceMappingURL=StateTransitionProvableBatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAoB,MAAM,MAAM,CAAC;AAK9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,qBAAa,mBAAmB;IAC9B,gBAAuB,MAAM,QAAQ;IAErC,gBAAuB,QAAQ,SAAS;WAE1B,QAAQ,CAAC,IAAI,EAAE,OAAO;WAItB,UAAU,CAAC,IAAI,EAAE,OAAO;CAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,2BAA4B,SAAQ,gCAE/C;IACA,WAAkB,MAAM,IAAI,2BAA2B,CAItD;IAED,WAAkB,QAAQ,IAAI,2BAA2B,CAIxD;IAEM,QAAQ,IAAI,IAAI;IAIhB,UAAU,IAAI,IAAI;CAG1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;;;;;GAMG;AACH,qBAAa,4BAA6B,SAAQ,iCAUhD;WACc,YAAY,CACxB,WAAW,EAAE;QACX,UAAU,EAAE,uBAAuB,CAAC;QACpC,IAAI,EAAE,2BAA2B,CAAC;KACnC,EAAE,GACF,4BAA4B;WAyBjB,eAAe,CAC3B,WAAW,EAAE,uBAAuB,EAAE,EACtC,mBAAmB,EAAE,uBAAuB,EAAE,GAC7C,4BAA4B;IAsB/B,OAAO;CAMR"}

package/dist/model/StateTransitionProvableBatch.js

@@ -0,0 +1,85 @@
+import { Bool, Provable, Struct } from "o1js";
+import { range } from "@proto-kit/common";
+import { constants } from "../Constants";
+import { ProvableStateTransition } from "./StateTransition.js";
+export class StateTransitionType {
+    static isNormal(type) {
+        return type === StateTransitionType.normal;
+    }
+    static isProtocol(type) {
+        return type === StateTransitionType.protocol;
+    }
+}
+StateTransitionType.normal = true;
+StateTransitionType.protocol = false;
+export class ProvableStateTransitionType extends Struct({
+    type: Bool,
+}) {
+    static get normal() {
+        return new ProvableStateTransitionType({
+            type: Bool(StateTransitionType.normal),
+        });
+    }
+    static get protocol() {
+        return new ProvableStateTransitionType({
+            type: Bool(StateTransitionType.protocol),
+        });
+    }
+    isNormal() {
+        return this.type;
+    }
+    isProtocol() {
+        return this.type.not();
+    }
+}
+/**
+ * A Batch of StateTransitions to be consumed by the StateTransitionProver
+ * to prove multiple STs at once
+ *
+ * transitionType:
+ * true == normal ST, false == protocol ST
+ */
+export class StateTransitionProvableBatch extends Struct({
+    batch: Provable.Array(ProvableStateTransition, constants.stateTransitionProverBatchSize),
+    transitionTypes: Provable.Array(ProvableStateTransitionType, constants.stateTransitionProverBatchSize),
+}) {
+    static fromMappings(transitions) {
+        const batch = transitions.map((entry) => entry.transition);
+        const transitionTypes = transitions.map((entry) => entry.type);
+        // Check that order is correct
+        let normalSTsStarted = false;
+        transitionTypes.forEach((x) => {
+            if (!normalSTsStarted && x.isNormal().toBoolean()) {
+                normalSTsStarted = true;
+            }
+            if (normalSTsStarted && x.isProtocol().toBoolean()) {
+                throw new Error("Order in initializing STBatch not correct");
+            }
+        });
+        while (batch.length < constants.stateTransitionProverBatchSize) {
+            batch.push(ProvableStateTransition.dummy());
+            transitionTypes.push(ProvableStateTransitionType.normal);
+        }
+        return new StateTransitionProvableBatch({
+            batch,
+            transitionTypes,
+        });
+    }
+    static fromTransitions(transitions, protocolTransitions) {
+        const array = transitions.slice().concat(protocolTransitions);
+        const transitionTypes = range(0, transitions.length)
+            .map(() => ProvableStateTransitionType.normal)
+            .concat(range(0, protocolTransitions.length).map(() => ProvableStateTransitionType.protocol));
+        while (array.length < constants.stateTransitionProverBatchSize) {
+            array.push(ProvableStateTransition.dummy());
+            transitionTypes.push(ProvableStateTransitionType.normal);
+        }
+        return new StateTransitionProvableBatch({
+            batch: array,
+            transitionTypes,
+        });
+    }
+    constructor(object) {
+        super(object);
+    }
+}

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

@@ -0,0 +1,160 @@
+import { Field, UInt64 } from "o1js";
+declare const CurrentBlock_base: (new (value: {
+    height: UInt64;
+}) => {
+    height: UInt64;
+}) & {
+    _isStruct: true;
+} & 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("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        height: UInt64;
+    }) => {
+        height: string;
+    };
+    fromJSON: (x: {
+        height: string;
+    }) => {
+        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;
+} & 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("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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,31 @@
+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),
+            ...PreviousBlock.toFields(this.previous),
+        ]);
+    }
+    static empty() {
+        return new NetworkState({
+            block: {
+                height: UInt64.zero,
+            },
+            previous: {
+                rootHash: Field(RollupMerkleTree.EMPTY_ROOT),
+            },
+        });
+    }
+}

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

@@ -0,0 +1,122 @@
+import { Bool, Field, PublicKey, UInt64 } from "o1js";
+import { PublicKeyOption, UInt64Option } from "./ValueOption";
+declare const RuntimeTransaction_base: (new (value: {
+    methodId: import("o1js/dist/node/lib/provable/field").Field;
+    argsHash: import("o1js/dist/node/lib/provable/field").Field;
+    nonce: UInt64Option;
+    sender: PublicKeyOption;
+}) => {
+    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("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: {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        argsHash: import("o1js/dist/node/lib/provable/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        argsHash: import("o1js/dist/node/lib/provable/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
+    }) => {
+        methodId: string;
+        argsHash: string;
+        nonce: {
+            isSome: boolean;
+            value: any;
+        };
+        sender: {
+            isSome: boolean;
+            value: any;
+        };
+    };
+    fromJSON: (x: {
+        methodId: string;
+        argsHash: string;
+        nonce: {
+            isSome: boolean;
+            value: any;
+        };
+        sender: {
+            isSome: boolean;
+            value: any;
+        };
+    }) => {
+        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;
+    };
+};
+/**
+ * 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 declare class RuntimeTransaction extends RuntimeTransaction_base {
+    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;
+    hashData(): Field[];
+    static fromHashData(fields: Field[]): RuntimeTransaction;
+    hash(): Field;
+}
+export {};
+//# sourceMappingURL=RuntimeTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"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,QAAQ,IAAI,KAAK,EAAE;WASZ,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE;IAiBnC,IAAI,IAAI,KAAK;CAGrB"}

package/dist/model/transaction/RuntimeTransaction.js

@@ -0,0 +1,86 @@
+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({
+    methodId: Field,
+    argsHash: Field,
+    nonce: UInt64Option,
+    sender: PublicKeyOption,
+}) {
+    static fromTransaction(input) {
+        return new RuntimeTransaction({
+            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),
+        });
+    }
+    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");
+    }
+    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());
+    }
+}