Enable custom network signing

src/lib/account-update.ts

@@ -41,7 +41,11 @@ import {
   protocolVersions,
 } from '../bindings/crypto/constants.js';
 import { MlArray } from './ml/base.js';
-import { Signature, signFieldElement } from '../mina-signer/src/signature.js';
+import {
+  Signature,
+  signFieldElement,
+  zkAppBodyPrefix,
+} from '../mina-signer/src/signature.js';
 import { MlFieldConstArray } from './ml/fields.js';
 import {
   accountUpdatesToCallForest,
@@ -1018,9 +1022,7 @@ class AccountUpdate implements Types.AccountUpdate {
     if (Provable.inCheckedComputation()) {
       let input = Types.AccountUpdate.toInput(this);
       return hashWithPrefix(
-        activeInstance.getNetworkId() === 'mainnet'
-          ? prefixes.zkappBodyMainnet
-          : prefixes.zkappBodyTestnet,
+        zkAppBodyPrefix(activeInstance.getNetworkId()),
         packToFields(input)
       );
     } else {
@@ -1399,9 +1401,7 @@ class AccountUpdate implements Types.AccountUpdate {
 function hashAccountUpdate(update: AccountUpdate) {
   return genericHash(
     AccountUpdate,
-    activeInstance.getNetworkId() === 'mainnet'
-      ? prefixes.zkappBodyMainnet
-      : prefixes.zkappBodyTestnet,
+    zkAppBodyPrefix(activeInstance.getNetworkId()),
     update
   );
 }

src/mina-signer/mina-signer.ts

@@ -39,16 +39,14 @@ export { Client as default };
 const defaultValidUntil = '4294967295';
 
 class Client {
-  private network: NetworkId; // TODO: Rename to "networkId" for consistency with remaining codebase.
+  private network: NetworkId;
 
   constructor(options: { network: NetworkId }) {
     if (!options?.network) {
       throw Error('Invalid Specified Network');
     }
     const specifiedNetwork = options.network.toLowerCase();
-    if (specifiedNetwork !== 'mainnet' && specifiedNetwork !== 'testnet') {
-      throw Error('Invalid Specified Network');
-    }
+
     this.network = specifiedNetwork;
   }
 
@@ -122,9 +120,13 @@ class Client {
    * @param privateKey The private key used for signing
    * @returns The signed field elements
    */
-  signFields(fields: bigint[], privateKey: Json.PrivateKey): Signed<bigint[]> {
+  signFields(
+    fields: bigint[],
+    privateKey: Json.PrivateKey,
+    network?: NetworkId
+  ): Signed<bigint[]> {
     let privateKey_ = PrivateKey.fromBase58(privateKey);
-    let signature = sign({ fields }, privateKey_, 'testnet');
+    let signature = sign({ fields }, privateKey_, network ?? 'testnet');
     return {
       signature: Signature.toBase58(signature),
       publicKey: PublicKey.toBase58(PrivateKey.toPublicKey(privateKey_)),
@@ -139,12 +141,15 @@ class Client {
    * @returns True if the `signedFields` contains a valid signature matching
    * the fields and publicKey.
    */
-  verifyFields({ data, signature, publicKey }: Signed<bigint[]>) {
+  verifyFields(
+    { data, signature, publicKey }: Signed<bigint[]>,
+    network?: NetworkId
+  ) {
     return verify(
       Signature.fromBase58(signature),
       { fields: data },
       PublicKey.fromBase58(publicKey),
-      'testnet'
+      network ?? 'testnet'
     );
   }
 

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

@@ -141,6 +141,6 @@ const RandomTransaction = {
   zkappCommand,
   zkappCommandAndFeePayerKey,
   zkappCommandJson,
-  networkId: Random.oneOf<NetworkId[]>('testnet', 'mainnet'),
+  networkId: Random.oneOf<NetworkId[]>('testnet', 'mainnet', 'other'),
   accountUpdateWithCallDepth: accountUpdate,
 };

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

@@ -15,6 +15,7 @@ import {
   Signature,
   signFieldElement,
   verifyFieldElement,
+  zkAppBodyPrefix,
 } from './signature.js';
 import { mocks } from '../../bindings/crypto/constants.js';
 import { NetworkId } from './types.js';
@@ -159,18 +160,6 @@ function accountUpdatesToCallForest<A extends { body: { callDepth: number } }>(
   return forest;
 }
 
-const zkAppBodyPrefix = (network: string) => {
-  switch (network) {
-    case 'mainnet':
-      return prefixes.zkappBodyMainnet;
-    case 'testnet':
-      return prefixes.zkappBodyTestnet;
-
-    default:
-      return 'ZkappBody' + network;
-  }
-};
-
 function accountUpdateHash(update: AccountUpdate, networkId: NetworkId) {
   assertAuthorizationKindValid(update);
   let input = AccountUpdate.toInput(update);

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

@@ -82,42 +82,38 @@ expect(stringify(dummyInput.packed)).toEqual(
   stringify(dummyInputSnarky.packed)
 );
 
-test(Random.accountUpdate, (accountUpdate) => {
-  const testnetMinaInstance = Network({
-    networkId: 'testnet',
-    mina: 'http://localhost:8080/graphql',
-  });
-  const mainnetMinaInstance = Network({
-    networkId: 'mainnet',
-    mina: 'http://localhost:8080/graphql',
-  });
-
-  fixVerificationKey(accountUpdate);
-
-  // example account update
-  let accountUpdateJson: Json.AccountUpdate =
-    AccountUpdate.toJSON(accountUpdate);
-
-  // account update hash
-  let accountUpdateSnarky = AccountUpdateSnarky.fromJSON(accountUpdateJson);
-  let inputSnarky = TypesSnarky.AccountUpdate.toInput(accountUpdateSnarky);
-  let input = AccountUpdate.toInput(accountUpdate);
-  expect(toJSON(input.fields)).toEqual(toJSON(inputSnarky.fields));
-  expect(toJSON(input.packed)).toEqual(toJSON(inputSnarky.packed));
-
-  let packed = packToFields(input);
-  let packedSnarky = packToFieldsSnarky(inputSnarky);
-  expect(toJSON(packed)).toEqual(toJSON(packedSnarky));
-
-  let hashTestnet = accountUpdateHash(accountUpdate, 'testnet');
-  let hashMainnet = accountUpdateHash(accountUpdate, 'mainnet');
-  setActiveInstance(testnetMinaInstance);
-  let hashSnarkyTestnet = accountUpdateSnarky.hash();
-  setActiveInstance(mainnetMinaInstance);
-  let hashSnarkyMainnet = accountUpdateSnarky.hash();
-  expect(hashTestnet).toEqual(hashSnarkyTestnet.toBigInt());
-  expect(hashMainnet).toEqual(hashSnarkyMainnet.toBigInt());
-});
+test(
+  Random.accountUpdate,
+  RandomTransaction.networkId,
+  (accountUpdate, networkId) => {
+    const minaInstance = Network({
+      networkId,
+      mina: 'http://localhost:8080/graphql',
+    });
+
+    fixVerificationKey(accountUpdate);
+
+    // example account update
+    let accountUpdateJson: Json.AccountUpdate =
+      AccountUpdate.toJSON(accountUpdate);
+
+    // account update hash
+    let accountUpdateSnarky = AccountUpdateSnarky.fromJSON(accountUpdateJson);
+    let inputSnarky = TypesSnarky.AccountUpdate.toInput(accountUpdateSnarky);
+    let input = AccountUpdate.toInput(accountUpdate);
+    expect(toJSON(input.fields)).toEqual(toJSON(inputSnarky.fields));
+    expect(toJSON(input.packed)).toEqual(toJSON(inputSnarky.packed));
+
+    let packed = packToFields(input);
+    let packedSnarky = packToFieldsSnarky(inputSnarky);
+    expect(toJSON(packed)).toEqual(toJSON(packedSnarky));
+
+    setActiveInstance(minaInstance);
+    let hashSnarky = accountUpdateSnarky.hash();
+    let hash = accountUpdateHash(accountUpdate, networkId);
+    expect(hash).toEqual(hashSnarky.toBigInt());
+  }
+);
 
 // private key to/from base58
 test(Random.json.privateKey, (feePayerKeyBase58) => {
@@ -140,19 +136,25 @@ test(memoGenerator, (memoString) => {
 });
 
 // zkapp transaction - basic properties & commitment
-test(RandomTransaction.zkappCommand, (zkappCommand, assert) => {
-  zkappCommand.accountUpdates.forEach(fixVerificationKey);
-
-  assert(isCallDepthValid(zkappCommand));
-  let zkappCommandJson = ZkappCommand.toJSON(zkappCommand);
-  let ocamlCommitments = Test.hashFromJson.transactionCommitments(
-    JSON.stringify(zkappCommandJson),
-    'testnet'
-  );
-  let callForest = accountUpdatesToCallForest(zkappCommand.accountUpdates);
-  let commitment = callForestHash(callForest, 'testnet');
-  expect(commitment).toEqual(FieldConst.toBigint(ocamlCommitments.commitment));
-});
+test(
+  RandomTransaction.zkappCommand,
+  RandomTransaction.networkId,
+  (zkappCommand, networkId, assert) => {
+    zkappCommand.accountUpdates.forEach(fixVerificationKey);
+
+    assert(isCallDepthValid(zkappCommand));
+    let zkappCommandJson = ZkappCommand.toJSON(zkappCommand);
+    let ocamlCommitments = Test.hashFromJson.transactionCommitments(
+      JSON.stringify(zkappCommandJson),
+      networkId
+    );
+    let callForest = accountUpdatesToCallForest(zkappCommand.accountUpdates);
+    let commitment = callForestHash(callForest, networkId);
+    expect(commitment).toEqual(
+      FieldConst.toBigint(ocamlCommitments.commitment)
+    );
+  }
+);
 
 // invalid zkapp transactions
 test.negative(
@@ -242,7 +244,7 @@ test(
     let sigOCaml = Test.signature.signFieldElement(
       ocamlCommitments.fullCommitment,
       Ml.fromPrivateKey(feePayerKeySnarky),
-      networkId === 'mainnet' ? true : false
+      networkId
     );
 
     expect(Signature.toBase58(sigFieldElements)).toEqual(sigOCaml);

src/mina-signer/src/signature.ts

@@ -39,6 +39,8 @@ export {
   signLegacy,
   verifyLegacy,
   deriveNonce,
+  signaturePrefix,
+  zkAppBodyPrefix,
 };
 
 const networkIdMainnet = 0x01n;
@@ -150,10 +152,10 @@ function deriveNonce(
 ): Scalar {
   let { x, y } = publicKey;
   let d = Field(privateKey);
-  let id = networkId === 'mainnet' ? networkIdMainnet : networkIdTestnet;
+  let id = getNetworkIdHashInput(networkId);
   let input = HashInput.append(message, {
     fields: [x, y, d],
-    packed: [[id, 8]],
+    packed: [id],
   });
   let packedInput = packToFields(input);
   let inputBits = packedInput.map(Field.toBits).flat();
@@ -189,11 +191,7 @@ function hashMessage(
 ): Scalar {
   let { x, y } = publicKey;
   let input = HashInput.append(message, { fields: [x, y, r] });
-  let prefix =
-    networkId === 'mainnet'
-      ? prefixes.signatureMainnet
-      : prefixes.signatureTestnet;
-  return hashWithPrefix(prefix, packToFields(input));
+  return hashWithPrefix(signaturePrefix(networkId), packToFields(input));
 }
 
 /**
@@ -280,7 +278,7 @@ function deriveNonceLegacy(
 ): Scalar {
   let { x, y } = publicKey;
   let scalarBits = Scalar.toBits(privateKey);
-  let id = networkId === 'mainnet' ? networkIdMainnet : networkIdTestnet;
+  let id = getNetworkIdHashInput(networkId)[0];
   let idBits = bytesToBits([Number(id)]);
   let input = HashInputLegacy.append(message, {
     fields: [x, y],
@@ -311,9 +309,65 @@ function hashMessageLegacy(
 ): Scalar {
   let { x, y } = publicKey;
   let input = HashInputLegacy.append(message, { fields: [x, y, r], bits: [] });
-  let prefix =
-    networkId === 'mainnet'
-      ? prefixes.signatureMainnet
-      : prefixes.signatureTestnet;
+  let prefix = signaturePrefix(networkId);
   return HashLegacy.hashWithPrefix(prefix, packToFieldsLegacy(input));
 }
+
+const toBytePadded = (b: number) => ('000000000' + b.toString(2)).substr(-8);
+
+function networkIdOfString(n: string): [bigint, number] {
+  let l = n.length;
+  let acc = '';
+  for (let i = l - 1; i >= 0; i--) {
+    let b = n.charCodeAt(i);
+    let padded = toBytePadded(b);
+    acc = acc.concat(padded);
+  }
+  return [BigInt('0b' + acc), acc.length];
+}
+
+function getNetworkIdHashInput(networkId: string): [bigint, number] {
+  switch (networkId) {
+    case 'mainnet':
+      return [networkIdMainnet, 8];
+    case 'testnet':
+      return [networkIdTestnet, 8];
+    default:
+      return networkIdOfString(networkId);
+  }
+}
+
+const createCustomPrefix = (prefix: string) => {
+  const maxLength = 20;
+  const paddingChar = '*';
+  let length = prefix.length;
+
+  if (length <= maxLength) {
+    let diff = maxLength - length;
+    return prefix + paddingChar.repeat(diff);
+  } else {
+    return prefix.substring(0, maxLength);
+  }
+};
+
+const signaturePrefix = (network: string) => {
+  switch (network) {
+    case 'mainnet':
+      return prefixes.signatureMainnet;
+    case 'testnet':
+      return prefixes.signatureTestnet;
+    default:
+      return createCustomPrefix(network + 'Signature');
+  }
+};
+
+const zkAppBodyPrefix = (network: string) => {
+  switch (network) {
+    case 'mainnet':
+      return prefixes.zkappBodyMainnet;
+    case 'testnet':
+      return prefixes.zkappBodyTestnet;
+    default:
+      return createCustomPrefix(network + 'ZkappBody');
+  }
+};