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

package/dist/model/StateTransition.d.ts

@@ -1,4 +1,4 @@
-import { Field } from "o1js";
+import { Field, ProvablePure } from "o1js";
 import { Option, ProvableOption } from "./Option";
 declare const ProvableStateTransition_base: (new (value: {
     path: import("o1js/dist/node/lib/field").Field;
@@ -10,7 +10,7 @@ declare const ProvableStateTransition_base: (new (value: {
     to: ProvableOption;
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
+} & ProvablePure<{
     path: import("o1js/dist/node/lib/field").Field;
     from: ProvableOption;
     to: ProvableOption;
@@ -68,12 +68,12 @@ export declare class ProvableStateTransition extends ProvableStateTransition_bas
  */
 export declare class StateTransition<Value> {
     path: Field;
-    fromValue: Option<Field> | Option<Value>;
+    fromValue: Option<Value>;
     toValue: Option<Field> | Option<Value>;
     static from<Value>(path: Field, fromValue: Option<Value>): StateTransition<Value>;
     static fromTo<Value>(path: Field, fromValue: Option<Value>, toValue: Option<Value>): StateTransition<Value>;
-    constructor(path: Field, fromValue: Option<Field> | Option<Value>, toValue: Option<Field> | Option<Value>);
-    get from(): Option<import("o1js/dist/node/lib/field").Field> | Option<Value>;
+    constructor(path: Field, fromValue: Option<Value>, toValue: Option<Field> | Option<Value>);
+    get from(): Option<Value>;
     get to(): Option<import("o1js/dist/node/lib/field").Field> | Option<Value>;
     /**
      * Converts a StateTransition to a ProvableStateTransition,
@@ -93,6 +93,7 @@ export declare class StateTransition<Value> {
             value: string[];
         };
     };
+    toConstant(): StateTransition<Value>;
 }
 export {};
 //# sourceMappingURL=StateTransition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAU,MAAM,MAAM,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAQ3C;WACc,KAAK,IAAI,uBAAuB;CAO/C;AAED;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAcvB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;WAfjC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;WAIjD,MAAM,CAAC,KAAK,EACxB,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC;gBAMf,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,qEAId;IAED,IAAW,EAAE,qEAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;IAQrC,MAAM;;;;;;;;;;;;;CAOd"}
+{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,EAAE,YAAY,EAAU,MAAM,MAAM,CAAC;AAEzD,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAQ3C;WACc,KAAK,IAAI,uBAAuB;CAO/C;AAED;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAcvB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;WAfjC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;WAIjD,MAAM,CAAC,KAAK,EACxB,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC;gBAMf,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,kBAId;IAED,IAAW,EAAE,qEAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;IAQrC,MAAM;;;;;;;;;;;;;IAQN,UAAU,IAAI,eAAe,CAAC,KAAK,CAAC;CAO5C"}

package/dist/model/StateTransition.js

@@ -62,4 +62,7 @@ export class StateTransition {
             to: this.toValue.toJSON(),
         };
     }
+    toConstant() {
+        return new StateTransition(this.path.toConstant(), this.fromValue.toConstant(), this.toValue.toConstant());
+    }
 }

package/dist/model/StateTransitionReduction.d.ts

@@ -0,0 +1,3 @@
+import { StateTransition } from "./StateTransition";
+export declare function reduceStateTransitions(transitions: StateTransition<unknown>[]): StateTransition<unknown>[];
+//# sourceMappingURL=StateTransitionReduction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionReduction.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionReduction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACtC,eAAe,CAAC,OAAO,CAAC,EAAE,CA0B5B"}

package/dist/model/StateTransitionReduction.js

@@ -0,0 +1,26 @@
+import { StateTransition } from "./StateTransition";
+export function reduceStateTransitions(transitions) {
+    const reduced = [];
+    for (const st of transitions) {
+        if (reduced.length === 0) {
+            reduced.push(st);
+            continue;
+        }
+        const last = reduced.at(-1);
+        if (last.path.equals(st.path).toBoolean()) {
+            if (st.toValue.isSome.toBoolean()) {
+                reduced.pop();
+                reduced.push(new StateTransition(st.path, last.fromValue, st.toValue));
+            }
+            else {
+                // Do nothing, because we discard that ST
+                // { from: 5, to: 10 }, { from: 10, to: none }
+                // cancel the 2nd
+            }
+        }
+        else {
+            reduced.push(st);
+        }
+    }
+    return reduced;
+}

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

@@ -27,34 +27,74 @@ declare const CurrentBlock_base: (new (value: {
 };
 export declare class CurrentBlock extends CurrentBlock_base {
 }
+declare const PreviousBlock_base: (new (value: {
+    rootHash: import("o1js/dist/node/lib/field").Field;
+}) => {
+    rootHash: import("o1js/dist/node/lib/field").Field;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    rootHash: import("o1js/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        rootHash: import("o1js/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        rootHash: import("o1js/dist/node/lib/field").Field;
+    }) => {
+        rootHash: string;
+    };
+    fromJSON: (x: {
+        rootHash: string;
+    }) => {
+        rootHash: import("o1js/dist/node/lib/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("o1js/dist/node/snarky").ProvablePure<{
     block: CurrentBlock;
+    previous: PreviousBlock;
 }> & {
     toInput: (x: {
         block: CurrentBlock;
+        previous: PreviousBlock;
     }) => {
         fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
         packed?: [import("o1js/dist/node/lib/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;
     };
 };
 export declare class NetworkState extends NetworkState_base {

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,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvD,qBAAa,YAAa,SAAQ,iBAEhC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAEhC;IACO,IAAI,IAAI,KAAK;WAIN,KAAK;CAOpB"}
+{"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,19 +1,31 @@
-import { Poseidon, Struct, UInt64 } from "o1js";
+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));
+        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

@@ -1,53 +1,65 @@
-import { Field, PublicKey, UInt64 } from "o1js";
-import { ProtocolTransaction } from "./ProtocolTransaction";
+import { Bool, Field, Provable, PublicKey, UInt64 } from "o1js";
+import { PublicKeyOption, UInt64Option } from "./ValueOption";
 declare const RuntimeTransaction_base: (new (value: {
     methodId: import("o1js/dist/node/lib/field").Field;
-    nonce: UInt64;
-    sender: PublicKey;
     argsHash: import("o1js/dist/node/lib/field").Field;
+    nonce: UInt64Option;
+    sender: PublicKeyOption;
 }) => {
     methodId: import("o1js/dist/node/lib/field").Field;
-    nonce: UInt64;
-    sender: PublicKey;
     argsHash: import("o1js/dist/node/lib/field").Field;
+    nonce: UInt64Option;
+    sender: PublicKeyOption;
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
+} & Provable<{
     methodId: import("o1js/dist/node/lib/field").Field;
-    nonce: UInt64;
-    sender: PublicKey;
     argsHash: import("o1js/dist/node/lib/field").Field;
+    nonce: UInt64Option;
+    sender: PublicKeyOption;
 }> & {
     toInput: (x: {
         methodId: import("o1js/dist/node/lib/field").Field;
-        nonce: UInt64;
-        sender: PublicKey;
         argsHash: import("o1js/dist/node/lib/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
     }) => {
         fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
         packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
     };
     toJSON: (x: {
         methodId: import("o1js/dist/node/lib/field").Field;
-        nonce: UInt64;
-        sender: PublicKey;
         argsHash: import("o1js/dist/node/lib/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
     }) => {
         methodId: string;
-        nonce: string;
-        sender: string;
         argsHash: string;
+        nonce: {
+            isSome: boolean;
+            value: any;
+        };
+        sender: {
+            isSome: boolean;
+            value: any;
+        };
     };
     fromJSON: (x: {
         methodId: string;
-        nonce: string;
-        sender: string;
         argsHash: string;
+        nonce: {
+            isSome: boolean;
+            value: any;
+        };
+        sender: {
+            isSome: boolean;
+            value: any;
+        };
     }) => {
         methodId: import("o1js/dist/node/lib/field").Field;
-        nonce: UInt64;
-        sender: PublicKey;
         argsHash: import("o1js/dist/node/lib/field").Field;
+        nonce: UInt64Option;
+        sender: PublicKeyOption;
     };
 };
 /**
@@ -56,7 +68,20 @@ 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({ methodId, 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;
+    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,MAAM,CAAC;AAElE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,uBAKtC;WACc,uBAAuB,CAAC,EACpC,QAAQ,EACR,KAAK,EACL,MAAM,EACN,QAAQ,GACT,EAAE,mBAAmB,GAAG,kBAAkB;IASpC,IAAI,IAAI,KAAK;CAQrB"}
+{"version":3,"file":"RuntimeTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/RuntimeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,KAAK,EAEL,QAAQ,EACR,SAAS,EAET,MAAM,EACP,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9D;;;;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

@@ -1,4 +1,6 @@
-import { Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
+import { Bool, Field, Poseidon, 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
  * execution. This class has not all data included in transactions on purpose.
@@ -6,24 +8,79 @@ import { Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
  */
 export class RuntimeTransaction extends Struct({
     methodId: Field,
-    nonce: UInt64,
-    sender: PublicKey,
     argsHash: Field,
+    nonce: UInt64Option,
+    sender: PublicKeyOption,
 }) {
-    static fromProtocolTransaction({ methodId, nonce, sender, argsHash, }) {
+    static fromTransaction(input) {
+        return new RuntimeTransaction({
+            methodId: input.methodId,
+            argsHash: input.argsHash,
+            nonce: UInt64Option.fromValue(input.nonce),
+            sender: PublicKeyOption.fromValue(input.sender),
+        });
+    }
+    static fromMessage({ methodId, argsHash, }) {
         return new RuntimeTransaction({
             methodId,
-            nonce,
-            sender,
             argsHash,
+            nonce: UInt64Option.none(UInt64.zero),
+            sender: PublicKeyOption.none(EMPTY_PUBLICKEY),
         });
     }
-    hash() {
-        return Poseidon.hash([
+    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.toFields(),
-            ...this.nonce.toFields(),
+            ...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());
     }
 }

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

@@ -0,0 +1,71 @@
+import { Bool, Field, Signature, UInt64 } from "o1js";
+import { RuntimeTransaction } from "./RuntimeTransaction";
+declare const SignedTransaction_base: (new (value: {
+    transaction: RuntimeTransaction;
+    signature: Signature;
+}) => {
+    transaction: RuntimeTransaction;
+    signature: Signature;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/lib/provable").Provable<{
+    transaction: RuntimeTransaction;
+    signature: Signature;
+}> & {
+    toInput: (x: {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+    }) => {
+        transaction: {
+            methodId: string;
+            argsHash: string;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
+        };
+        signature: any;
+    };
+    fromJSON: (x: {
+        transaction: {
+            methodId: string;
+            argsHash: string;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
+        };
+        signature: any;
+    }) => {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+    };
+};
+export declare class SignedTransaction extends SignedTransaction_base {
+    static getSignatureData(args: {
+        methodId: Field;
+        nonce: UInt64;
+        argsHash: Field;
+    }): Field[];
+    static dummy(): SignedTransaction;
+    hash(): Field;
+    getSignatureData(): Field[];
+    validateSignature(): Bool;
+}
+export {};
+//# sourceMappingURL=SignedTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SignedTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/SignedTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,KAAK,EAEL,SAAS,EAET,MAAM,EACP,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1D,qBAAa,iBAAkB,SAAQ,sBAGrC;WACc,gBAAgB,CAAC,IAAI,EAAE;QACnC,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,KAAK,CAAC;KACjB,GAAG,KAAK,EAAE;WAIG,KAAK,IAAI,iBAAiB;IAWjC,IAAI,IAAI,KAAK;IAIb,gBAAgB,IAAI,KAAK,EAAE;IAS3B,iBAAiB,IAAI,IAAI;CAMjC"}

package/dist/model/transaction/SignedTransaction.js

@@ -0,0 +1,33 @@
+import { Field, Scalar, Signature, Struct, } from "o1js";
+import { RuntimeTransaction } from "./RuntimeTransaction";
+export class SignedTransaction extends Struct({
+    transaction: RuntimeTransaction,
+    signature: Signature,
+}) {
+    static getSignatureData(args) {
+        return [args.methodId, ...args.nonce.value.toFields(), args.argsHash];
+    }
+    static dummy() {
+        return new SignedTransaction({
+            transaction: RuntimeTransaction.dummyTransaction(),
+            signature: Signature.fromObject({
+                s: Scalar.from(0),
+                r: Field(0),
+            }),
+        });
+    }
+    hash() {
+        return this.transaction.hash();
+    }
+    getSignatureData() {
+        const { methodId, argsHash, nonce } = this.transaction;
+        return SignedTransaction.getSignatureData({
+            nonce: nonce.value,
+            methodId,
+            argsHash,
+        });
+    }
+    validateSignature() {
+        return this.signature.verify(this.transaction.sender.value, this.getSignatureData());
+    }
+}

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

@@ -0,0 +1,119 @@
+import { PublicKey, UInt64 } from "o1js";
+declare const UInt64Option_base: {
+    new (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+    fromValue(value: UInt64): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+    none(value: UInt64): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+    _isStruct: true;
+    toFields: (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }) => import("o1js/dist/node/lib/field").Field[];
+    toAuxiliary: (value?: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    } | undefined) => any[];
+    fromFields: (fields: import("o1js/dist/node/lib/field").Field[], aux: any[]) => {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+    sizeInFields(): number;
+    check: (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }) => void;
+    toInput: (x: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }) => {
+        isSome: boolean;
+        value: any;
+    };
+    fromJSON: (x: {
+        isSome: boolean;
+        value: any;
+    }) => {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+};
+export declare class UInt64Option extends UInt64Option_base {
+}
+declare const PublicKeyOption_base: {
+    new (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+    fromValue(value: PublicKey): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+    none(value: PublicKey): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+    _isStruct: true;
+    toFields: (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }) => import("o1js/dist/node/lib/field").Field[];
+    toAuxiliary: (value?: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    } | undefined) => any[];
+    fromFields: (fields: import("o1js/dist/node/lib/field").Field[], aux: any[]) => {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+    sizeInFields(): number;
+    check: (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }) => void;
+    toInput: (x: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }) => {
+        isSome: boolean;
+        value: any;
+    };
+    fromJSON: (x: {
+        isSome: boolean;
+        value: any;
+    }) => {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+};
+export declare class PublicKeyOption extends PublicKeyOption_base {
+}
+export {};
+//# sourceMappingURL=ValueOption.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueOption.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/ValueOption.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBzE,qBAAa,YAAa,SAAQ,iBAAoC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzE,qBAAa,eAAgB,SAAQ,oBAEpC;CAAG"}

package/dist/model/transaction/ValueOption.js

@@ -0,0 +1,24 @@
+import { Bool, PublicKey, Struct, UInt64 } from "o1js";
+function genericOptionFactory(valueType) {
+    return class Generic extends Struct({
+        isSome: Bool,
+        value: valueType,
+    }) {
+        static fromValue(value) {
+            return new Generic({
+                isSome: Bool(true),
+                value,
+            });
+        }
+        static none(value) {
+            return new Generic({
+                isSome: Bool(false),
+                value,
+            });
+        }
+    };
+}
+export class UInt64Option extends genericOptionFactory(UInt64) {
+}
+export class PublicKeyOption extends genericOptionFactory(PublicKey) {
+}