Fix SnarkyJS to be compatible with new Berkeley

src/lib/account_update.ts

@@ -33,6 +33,7 @@ import { MlArray } from './ml/base.js';
 import { Signature, signFieldElement } from '../mina-signer/src/signature.js';
 import { MlFieldConstArray } from './ml/fields.js';
 import { transactionCommitments } from '../mina-signer/src/sign-zkapp-command.js';
+import { Field as Fp } from './field.js';
 
 // external API
 export { AccountUpdate, Permissions, ZkappPublicInput };
@@ -445,7 +446,7 @@ const Body = {
     tokenId?: Field,
     mayUseToken?: MayUseToken
   ): Body {
-    let { body } = Types.AccountUpdate.emptyValue();
+    let { body } = AccountUpdate.emptyValue();
     body.publicKey = publicKey;
     if (tokenId) {
       body.tokenId = tokenId;
@@ -463,7 +464,7 @@ const Body = {
   },
 
   dummy(): Body {
-    return Types.AccountUpdate.emptyValue().body;
+    return AccountUpdate.emptyValue().body;
   },
 };
 
@@ -1288,6 +1289,12 @@ class AccountUpdate implements Types.AccountUpdate {
       other
     );
   }
+  static emptyValue() {
+    let empty = Types.AccountUpdate.emptyValue();
+    empty.body.authorizationKind.verificationKeyHash =
+      dummyVerificationKeyHash();
+    return empty;
+  }
 
   static witness<T>(
     type: FlexibleProvable<T>,
@@ -1802,7 +1809,8 @@ const Authorization = {
     signature ??= {};
     accountUpdate.body.authorizationKind.isSigned = Bool(true);
     accountUpdate.body.authorizationKind.isProved = Bool(false);
-    accountUpdate.body.authorizationKind.verificationKeyHash = Field(0);
+    accountUpdate.body.authorizationKind.verificationKeyHash =
+      dummyVerificationKeyHash();
     accountUpdate.authorization = {};
     accountUpdate.lazyAuthorization = { ...signature, kind: 'lazy-signature' };
   },
@@ -1860,7 +1868,8 @@ const Authorization = {
   setLazyNone(accountUpdate: AccountUpdate) {
     accountUpdate.body.authorizationKind.isSigned = Bool(false);
     accountUpdate.body.authorizationKind.isProved = Bool(false);
-    accountUpdate.body.authorizationKind.verificationKeyHash = Field(0);
+    accountUpdate.body.authorizationKind.verificationKeyHash =
+      dummyVerificationKeyHash();
     accountUpdate.authorization = {};
     accountUpdate.lazyAuthorization = { kind: 'lazy-none' };
   },
@@ -1946,6 +1955,11 @@ function dummySignature() {
   return Signature.toBase58(Signature.dummy());
 }
 
+function dummyVerificationKeyHash() {
+  let [, , hash] = Pickles.dummyVerificationKey();
+  return Fp.fromBytes([...hash]);
+}
+
 /**
  * The public input for zkApps consists of certain hashes of the proving
  AccountUpdate (and its child accountUpdates) which is constructed during method

src/lib/testing/random.ts

@@ -37,6 +37,7 @@ import { Memo } from '../../mina-signer/src/memo.js';
 import { ProvableExtended } from '../../bindings/lib/provable-bigint.js';
 import { tokenSymbolLength } from '../../bindings/mina-transaction/derived-leaves.js';
 import { stringLengthInBytes } from '../../bindings/lib/binable.js';
+import { Pickles } from '../../snarky.js';
 
 export { Random, sample, withHardCoded };
 
@@ -255,8 +256,12 @@ const accountUpdateJson = mapWithInvalid(
     if (isProved && isSigned) {
       a.body.authorizationKind.isProved = false;
     }
+
     if (!a.body.authorizationKind.isProved) {
-      a.body.authorizationKind.verificationKeyHash = '0';
+      let [, , hash] = Pickles.dummyVerificationKey();
+      a.body.authorizationKind.verificationKeyHash = Field.fromBytes([
+        ...hash,
+      ]).toString();
     }
     // ensure mayUseToken is valid
     let { inheritFromParent, parentsOwnToken } = a.body.mayUseToken;

src/mina-signer/MinaSigner.ts

@@ -198,7 +198,7 @@ class Client {
     let signature = signPayment(
       {
         common: { fee, feePayer: from, nonce, validUntil, memo },
-        body: { source: from, receiver: to, amount },
+        body: { receiver: to, amount },
       },
       privateKey,
       this.network
@@ -226,7 +226,7 @@ class Client {
     return verifyPayment(
       {
         common: { fee, feePayer: from, nonce, validUntil, memo },
-        body: { source: from, receiver: to, amount },
+        body: { receiver: to, amount },
       },
       signature,
       publicKey,
@@ -254,7 +254,7 @@ class Client {
     let signature = signStakeDelegation(
       {
         common: { fee, feePayer: from, nonce, validUntil, memo },
-        body: { newDelegate: to, delegator: from },
+        body: { newDelegate: to },
       },
       privateKey,
       this.network
@@ -281,7 +281,7 @@ class Client {
     return verifyStakeDelegation(
       {
         common: { fee, feePayer: from, nonce, validUntil, memo },
-        body: { newDelegate: to, delegator: from },
+        body: { newDelegate: to },
       },
       signature,
       publicKey,
@@ -306,7 +306,7 @@ class Client {
         signature,
         data: {
           common: { fee, feePayer: from, nonce, validUntil, memo },
-          body: { source: from, receiver: to, amount },
+          body: { receiver: to, amount },
         },
       },
       options
@@ -329,7 +329,7 @@ class Client {
         signature,
         data: {
           common: { fee, feePayer: from, nonce, validUntil, memo },
-          body: { newDelegate: to, delegator: from },
+          body: { newDelegate: to },
         },
       },
       options

src/mina-signer/src/random-transaction.ts

@@ -23,7 +23,6 @@ const common = record({
 const payment = record<PaymentJson>({
   common,
   body: record({
-    source: Random.json.publicKey,
     receiver: Random.json.publicKey,
     amount: Random.json.uint64,
   }),
@@ -36,7 +35,6 @@ const signedPayment = record<SignedLegacy<PaymentJson>>({
 const delegation = record<DelegationJson>({
   common,
   body: record({
-    delegator: Random.json.publicKey,
     newDelegate: Random.json.publicKey,
   }),
 });

src/mina-signer/src/sign-legacy.ts

@@ -23,7 +23,9 @@ export {
   delegationFromJson,
   commonFromJson,
   PaymentJson,
+  PaymentJsonV1,
   DelegationJson,
+  DelegationJsonV1,
   CommonJson,
   Tag,
   UserCommand,
@@ -146,7 +148,7 @@ function commonToInputLegacy({
     HashInputLegacy.bits(legacyTokenId),
     PublicKey.toInputLegacy(feePayer),
     HashInputLegacy.bits(UInt32.toBits(nonce)),
-    HashInputLegacy.bits(UInt32.toBits(validUntil)),
+    HashInputLegacy.bits(UInt32.toBits(validUntil.value)),
     HashInputLegacy.bits(Memo.toBits(memo)),
   ].reduce(HashInputLegacy.append);
 }
@@ -160,13 +162,13 @@ const legacyTokenId = [true, ...Array<boolean>(63).fill(false)];
 
 function paymentFromJson({
   common,
-  body: { source, receiver, amount },
+  body: { receiver, amount },
 }: PaymentJson): UserCommand {
   return {
     common: commonFromJson(common),
     body: {
       tag: 'Payment',
-      source: PublicKey.fromJSON(source),
+      source: PublicKey.fromJSON(common.feePayer),
       receiver: PublicKey.fromJSON(receiver),
       amount: UInt64.fromJSON(amount),
     },
@@ -175,25 +177,25 @@ function paymentFromJson({
 
 function delegationFromJson({
   common,
-  body: { delegator, newDelegate },
+  body: { newDelegate },
 }: DelegationJson): UserCommand {
   return {
     common: commonFromJson(common),
     body: {
       tag: 'StakeDelegation',
-      source: PublicKey.fromJSON(delegator),
+      source: PublicKey.fromJSON(common.feePayer),
       receiver: PublicKey.fromJSON(newDelegate),
       amount: UInt64(0),
     },
   };
 }
 
-function commonFromJson(c: CommonJson) {
+function commonFromJson(c: CommonJson): Common {
   return {
     fee: UInt64.fromJSON(c.fee),
     feePayer: PublicKey.fromJSON(c.feePayer),
     nonce: UInt32.fromJSON(c.nonce),
-    validUntil: UInt32.fromJSON(c.validUntil),
+    validUntil: { type: 'SinceGenesis', value: UInt32.fromJSON(c.validUntil) },
     // TODO: this might need to be fromBase58
     memo: Memo.fromString(c.memo),
   };
@@ -262,17 +264,15 @@ type Common = {
   fee: UInt64;
   feePayer: PublicKey;
   nonce: UInt32;
-  validUntil: UInt32;
+  validUntil: { type: 'SinceGenesis'; value: UInt32 };
   memo: string;
 };
 
 type Payment = {
-  source: PublicKey;
   receiver: PublicKey;
   amount: UInt64;
 };
 type Delegation = {
-  delegator: PublicKey;
   newDelegate: PublicKey;
 };
 
@@ -285,6 +285,14 @@ type CommonJson = {
 };
 
 type PaymentJson = {
+  common: CommonJson;
+  body: {
+    receiver: Json.PublicKey;
+    amount: Json.UInt64;
+  };
+};
+
+type PaymentJsonV1 = {
   common: CommonJson;
   body: {
     source: Json.PublicKey;
@@ -294,6 +302,13 @@ type PaymentJson = {
 };
 
 type DelegationJson = {
+  common: CommonJson;
+  body: {
+    newDelegate: Json.PublicKey;
+  };
+};
+
+type DelegationJsonV1 = {
   common: CommonJson;
   body: {
     delegator: Json.PublicKey;

src/mina-signer/src/sign-legacy.unit-test.ts

@@ -106,13 +106,6 @@ let amountTooLarge = {
     amount: (2n ** 64n).toString(),
   },
 };
-let invalidPublicKey: PaymentJson = {
-  common: validPayment.common,
-  body: {
-    ...validPayment.body,
-    source: PublicKey.toBase58({ x: 0n, isOdd: 0n }),
-  },
-};
 let signature = Signature.toJSON({ r: Field.random(), s: Scalar.random() });
 
 expect(() => signPayment(amountTooLarge, privateKey, 'mainnet')).toThrow(
@@ -122,13 +115,6 @@ expect(verifyPayment(amountTooLarge, signature, publicKey, 'mainnet')).toEqual(
   false
 );
 
-expect(() => signPayment(invalidPublicKey, privateKey, 'mainnet')).toThrow(
-  'not a valid group element'
-);
-expect(
-  verifyPayment(invalidPublicKey, signature, publicKey, 'mainnet')
-).toEqual(false);
-
 // negative tests with invalid signatures
 
 let garbageSignature = { field: 'garbage', scalar: 'garbage' };

src/mina-signer/src/sign-zkapp-command.ts

@@ -17,6 +17,7 @@ import {
   signFieldElement,
   verifyFieldElement,
 } from './signature.js';
+import { Pickles } from '../../snarky.js';
 
 // external API
 export { signZkappCommand, verifyZkappCommandSignature };
@@ -180,6 +181,7 @@ function accountUpdateFromFeePayer({
   authorization: signature,
 }: FeePayer): AccountUpdate {
   let { body } = AccountUpdate.emptyValue();
+  let [, , hash] = Pickles.dummyVerificationKey();
   body.publicKey = publicKey;
   body.balanceChange = { magnitude: fee, sgn: Sign(-1) };
   body.incrementNonce = Bool(true);
@@ -196,7 +198,7 @@ function accountUpdateFromFeePayer({
   body.authorizationKind = {
     isProved: Bool(false),
     isSigned: Bool(true),
-    verificationKeyHash: Field(0),
+    verificationKeyHash: Field.fromBytes([...hash]),
   };
   return { body, authorization: { signature } };
 }
@@ -216,12 +218,14 @@ function isCallDepthValid(zkappCommand: ZkappCommand) {
 function assertAuthorizationKindValid(accountUpdate: AccountUpdate) {
   let { isSigned, isProved, verificationKeyHash } =
     accountUpdate.body.authorizationKind;
+  let [, , hash] = Pickles.dummyVerificationKey();
+  const dummyVK = Field.fromBytes([...hash]);
   if (isProved && isSigned)
     throw Error(
       'Invalid authorization kind: Only one of `isProved` and `isSigned` may be true.'
     );
-  if (!isProved && verificationKeyHash !== 0n)
+  if (!isProved && verificationKeyHash !== dummyVK)
     throw Error(
-      `Invalid authorization kind: If \`isProved\` is false, verification key hash must be 0, got ${verificationKeyHash}`
+      `Invalid authorization kind: If \`isProved\` is false, verification key hash must be ${dummyVK}, got ${verificationKeyHash}`
     );
 }

src/mina-signer/src/sign-zkapp-command.unit-test.ts

@@ -62,6 +62,7 @@ test(Random.json.publicKey, (publicKeyBase58) => {
 
 // empty account update
 let dummy = AccountUpdate.emptyValue();
+fixVerificationKeyHash(dummy);
 let dummySnarky = AccountUpdateSnarky.dummy();
 expect(AccountUpdate.toJSON(dummy)).toEqual(
   AccountUpdateSnarky.toJSON(dummySnarky)
@@ -81,6 +82,7 @@ expect(stringify(dummyInput.packed)).toEqual(
 );
 
 test(Random.accountUpdate, (accountUpdate) => {
+  fixVerificationKeyHash(accountUpdate);
   fixVerificationKey(accountUpdate);
 
   // example account update
@@ -125,6 +127,7 @@ test(memoGenerator, (memoString) => {
 
 // zkapp transaction - basic properties & commitment
 test(RandomTransaction.zkappCommand, (zkappCommand, assert) => {
+  zkappCommand.accountUpdates.forEach(fixVerificationKeyHash);
   zkappCommand.accountUpdates.forEach(fixVerificationKey);
 
   assert(isCallDepthValid(zkappCommand));
@@ -151,6 +154,7 @@ test.negative(
 test(
   RandomTransaction.zkappCommandAndFeePayerKey,
   ({ feePayerKey, zkappCommand }) => {
+    zkappCommand.accountUpdates.forEach(fixVerificationKeyHash);
     zkappCommand.accountUpdates.forEach(fixVerificationKey);
 
     let feePayerKeyBase58 = PrivateKey.toBase58(feePayerKey);
@@ -280,3 +284,8 @@ function fixVerificationKey(a: AccountUpdate) {
     a.body.update.verificationKey.value = { data: '', hash: Field(0) };
   }
 }
+
+function fixVerificationKeyHash(a: AccountUpdate) {
+  let [, , hash] = Pickles.dummyVerificationKey();
+  a.body.authorizationKind.verificationKeyHash = Field.fromBytes([...hash]);
+}