Unlimited account update support

src/lib/mina/mina.ts

@@ -104,21 +104,24 @@ function Network(options: {
   mina: string | string[];
   archive?: string | string[];
   lightnetAccountManager?: string;
+  enforceTransactionLimits?: boolean;
 }): Mina;
 function Network(
   options:
     | {
-        networkId?: NetworkId;
-        mina: string | string[];
-        archive?: string | string[];
-        lightnetAccountManager?: string;
-      }
+      networkId?: NetworkId;
+      mina: string | string[];
+      archive?: string | string[];
+      lightnetAccountManager?: string;
+      enforceTransactionLimits?: boolean;
+    }
     | string
 ): Mina {
   let minaNetworkId: NetworkId = 'testnet';
   let minaGraphqlEndpoint: string;
   let archiveEndpoint: string;
   let lightnetAccountManagerEndpoint: string;
+  let enforceTransactionLimits: boolean = true;
 
   if (options && typeof options === 'string') {
     minaGraphqlEndpoint = options;
@@ -158,6 +161,11 @@ function Network(
       lightnetAccountManagerEndpoint = options.lightnetAccountManager;
       Fetch.setLightnetAccountManagerEndpoint(lightnetAccountManagerEndpoint);
     }
+
+    if (options.enforceTransactionLimits !== undefined &&
+      typeof options.enforceTransactionLimits === 'boolean') {
+      enforceTransactionLimits = options.enforceTransactionLimits;
+    }
   } else {
     throw new Error(
       "Network: malformed input. Please provide a string or an object with 'mina' and 'archive' endpoints."
@@ -251,7 +259,7 @@ function Network(
     },
     sendTransaction(txn) {
       return toPendingTransactionPromise(async () => {
-        verifyTransactionLimits(txn.transaction);
+        if (enforceTransactionLimits) verifyTransactionLimits(txn.transaction);
 
         let [response, error] = await Fetch.sendZkapp(txn.toJSON());
         let errors: string[] = [];

src/lib/mina/transaction.test.ts

@@ -0,0 +1,200 @@
+import {
+  State,
+  state,
+  UInt64,
+  Bool,
+  SmartContract,
+  Mina,
+  AccountUpdate,
+  method,
+  PublicKey,
+  Permissions,
+  VerificationKey,
+  Field,
+  Int64,
+  TokenId,
+  TokenContract as TokenContractBase,
+  AccountUpdateForest,
+  PrivateKey,
+} from 'o1js';
+
+
+
+const defaultNetwork = Mina.Network({
+  networkId: "testnet",
+  mina: "https://example.com/graphql",
+  archive: "https://example.com//graphql"
+});
+
+const enforcedNetwork = Mina.Network({
+  networkId: "testnet",
+  mina: "https://example.com/graphql",
+  archive: "https://example.com//graphql",
+  enforceTransactionLimits: true
+});
+
+const unlimitedNetwork = Mina.Network({
+  networkId: "testnet",
+  mina: "https://unlimited.com/graphql",
+  archive: "https://unlimited.com//graphql",
+  enforceTransactionLimits: false
+});
+
+describe('Test default network', () => {
+  let bobAccount: PublicKey,
+    bobKey: PrivateKey;
+
+  beforeAll(async () => {
+
+    Mina.setActiveInstance(defaultNetwork);
+    bobKey = PrivateKey.random();
+    bobAccount = bobKey.toPublicKey();
+  });
+
+
+  it('Simple account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(1));
+      accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+      accountUpdateBob.balance.addInPlace(UInt64.one);
+    });
+    await txn.prove();
+    await txn.sign([bobKey]).safeSend();
+
+  });
+
+  it('Multiple account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      for (let index = 0; index < 2; index++) {
+        const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(index));
+        accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+        accountUpdateBob.balance.addInPlace(UInt64.one);
+      }
+    });
+    await txn.prove();
+    await txn.sign([bobKey]).safeSend();
+
+  });
+
+  it('More than limit account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      for (let index = 0; index < 12; index++) {
+        const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(index));
+        accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+        accountUpdateBob.balance.addInPlace(UInt64.one);
+      }
+    });
+    await txn.prove();
+    // failure with default enforceTransactionLimits
+    await expect(txn.sign([bobKey]).safeSend()).rejects.toThrow();
+  });
+});
+
+describe('Test enforced network', () => {
+  let bobAccount: PublicKey,
+    bobKey: PrivateKey;
+
+  beforeAll(async () => {
+
+    Mina.setActiveInstance(enforcedNetwork);
+    bobKey = PrivateKey.random();
+    bobAccount = bobKey.toPublicKey();
+  });
+
+
+  it('Simple account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(1));
+      accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+      accountUpdateBob.balance.addInPlace(UInt64.one);
+    });
+    await txn.prove();
+    await txn.sign([bobKey]).safeSend();
+
+  });
+
+  it('Multiple account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      for (let index = 0; index < 2; index++) {
+        const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(index));
+        accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+        accountUpdateBob.balance.addInPlace(UInt64.one);
+      }
+    });
+    await txn.prove();
+    await txn.sign([bobKey]).safeSend();
+
+  });
+
+  it('More than limit account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      for (let index = 0; index < 12; index++) {
+        const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(index));
+        accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+        accountUpdateBob.balance.addInPlace(UInt64.one);
+      }
+    });
+    await txn.prove();
+    // failure with enforceTransactionLimits = true
+    await expect(txn.sign([bobKey]).safeSend()).rejects.toThrow();
+  });
+});
+
+describe('Test unlimited network', () => {
+  let bobAccount: PublicKey,
+    bobKey: PrivateKey;
+
+  beforeAll(async () => {
+
+    Mina.setActiveInstance(unlimitedNetwork);
+    bobKey = PrivateKey.random();
+    bobAccount = bobKey.toPublicKey();
+  });
+
+
+  it('Simple account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(1));
+      accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+      accountUpdateBob.balance.addInPlace(UInt64.one);
+    });
+    await txn.prove();
+    await txn.sign([bobKey]).safeSend();
+
+  });
+
+  it('Multiple account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      for (let index = 0; index < 2; index++) {
+        const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(index));
+        accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+        accountUpdateBob.balance.addInPlace(UInt64.one);
+      }
+    });
+    await txn.prove();
+    await txn.sign([bobKey]).safeSend();
+
+  });
+
+  it('More than limit account update', async () => {
+
+    let txn = await Mina.transaction(async () => {
+      for (let index = 0; index < 12; index++) {
+        const accountUpdateBob = AccountUpdate.create(bobAccount, Field.from(index));
+        accountUpdateBob.account.balance.requireEquals(UInt64.zero);
+        accountUpdateBob.balance.addInPlace(UInt64.one);
+      }
+    });
+    await txn.prove();
+    // success with enforceTransactionLimits = false
+    await txn.sign([bobKey]).safeSend();
+  });
+});