[DO NOT MERGE] updated: storage benchmarks

e2e/capacity/capacityFail.test.ts

@@ -21,7 +21,7 @@ import {
 import { getFundingSource } from '../scaffolding/funding';
 import { getUnifiedPublicKey } from '@frequency-chain/ethereum-utils';
 
-const FUNDS_AMOUNT: bigint = 50n * DOLLARS;
+const FUNDS_AMOUNT: bigint = 100n * DOLLARS;
 let fundingSource: KeyringPair;
 
 describe('Capacity Transaction Failures', function () {

e2e/capacity/replenishment.test.ts

@@ -40,7 +40,7 @@ describe('Capacity Replenishment Testing: ', function () {
   describe('Capacity is replenished', function () {
     it('after new epoch', async function () {
       const schemaId = await getOrCreateGraphChangeSchema(fundingSource);
-      const totalStaked = 3n * DOLLARS;
+      const totalStaked = 4n * DOLLARS;
       const expectedCapacity = totalStaked / getTokenPerCapacity();
       const [stakeKeys, stakeProviderId] = await createAndStakeProvider('ReplFirst', totalStaked);
       const payload = JSON.stringify({ changeType: 1, fromId: 1, objectId: 2 });
@@ -86,7 +86,7 @@ describe('Capacity Replenishment Testing: ', function () {
   describe('Capacity is not replenished', function () {
     it('if out of capacity and last_replenished_at is <= current epoch', async function () {
       const schemaId = await getOrCreateGraphChangeSchema(fundingSource);
-      const [stakeKeys, stakeProviderId] = await createAndStakeProvider('NoSend', 150n * CENTS);
+      const [stakeKeys, stakeProviderId] = await createAndStakeProvider('NoSend', 300n * CENTS);
       const payload = JSON.stringify({ changeType: 1, fromId: 1, objectId: 2 });
       const call = ExtrinsicHelper.addOnChainMessage(stakeKeys, schemaId, payload);
 

e2e/capacity/staking.test.ts

@@ -255,8 +255,8 @@ describe('Capacity Staking Tests', function () {
 
   describe('when staking and targeting an InvalidTarget', function () {
     it('fails to stake', async function () {
-      const stakeAmount = 10n * CENTS;
-      const [notProviderMsaId, stakeKeys] = await createMsa(fundingSource, 10n * CENTS);
+      const stakeAmount = 20n * CENTS;
+      const [notProviderMsaId, stakeKeys] = await createMsa(fundingSource, 20n * CENTS);
 
       const failStakeObj = ExtrinsicHelper.stake(stakeKeys, notProviderMsaId, stakeAmount);
       await assert.rejects(failStakeObj.signAndSend(), { name: 'InvalidTarget' });
@@ -277,7 +277,7 @@ describe('Capacity Staking Tests', function () {
   describe('when attempting to stake a zero amount', function () {
     it('fails to stake and errors ZeroAmountNotAllowed', async function () {
       const stakingKeys = createKeys('stakingKeys');
-      const providerId = await createMsaAndProvider(fundingSource, stakingKeys, 'stakingKeys', 10n * CENTS);
+      const providerId = await createMsaAndProvider(fundingSource, stakingKeys, 'stakingKeys', 20n * CENTS);
 
       const failStakeObj = ExtrinsicHelper.stake(stakingKeys, providerId, 0);
       await assert.rejects(failStakeObj.signAndSend(), { name: 'ZeroAmountNotAllowed' });
@@ -320,8 +320,8 @@ describe('Capacity Staking Tests', function () {
     }
 
     before(async function () {
-      vesterKeys = await createAndFundKeypair(fundingSource, 50_000_000n);
-      await assertSpendable(vesterKeys, 49n * BigInt(CENTS)); // less ED
+      vesterKeys = await createAndFundKeypair(fundingSource, 100_000_000n);
+      await assertSpendable(vesterKeys, 99n * BigInt(CENTS)); // less ED
       await assertFrozen(vesterKeys, 0n);
       providerKeys = await createAndFundKeypair(fundingSource, 10n * CENTS);
       providerId = await createMsaAndProvider(fundingSource, providerKeys, 'Provider Whale', 10n * DOLLARS);
@@ -342,7 +342,7 @@ describe('Capacity Staking Tests', function () {
 
       const spendable = await getSpendableBalance(vesterKeys);
       // after txn fees
-      assert(spendable > 47n * CENTS, `Expected spendable > 47 CENTS, got ${spendable}`);
+      assert(spendable > 92n * CENTS, `Expected spendable > 92 CENTS, got ${spendable}`);
     });
   });
 });

e2e/capacity/transactions.test.ts

@@ -45,14 +45,14 @@ import { ipfsCid } from '../messages/ipfs';
 import { getFundingSource } from '../scaffolding/funding';
 import { getUnifiedPublicKey } from '@frequency-chain/ethereum-utils';
 
-const FUNDS_AMOUNT: bigint = 50n * DOLLARS;
+const FUNDS_AMOUNT: bigint = 100n * DOLLARS;
 let fundingSource: KeyringPair;
 
 describe('Capacity Transactions', function () {
   describe('pay_with_capacity', function () {
     describe('when caller has a Capacity account', function () {
       let schemaId: u16;
-      const amountStaked = 3n * DOLLARS;
+      const amountStaked = 6n * DOLLARS;
 
       before(async function () {
         fundingSource = await getFundingSource(import.meta.url);
@@ -66,7 +66,7 @@ describe('Capacity Transactions', function () {
         let capacityProvider: u64;
         let delegatorKeys: KeyringPair;
         let payload: any = {};
-        const stakedForMsa = 15n * DOLLARS;
+        const stakedForMsa = 30n * DOLLARS;
 
         before(async function () {
           capacityKeys = createKeys('CapacityKeys');

e2e/capacity/transactionsBatch.test.ts

@@ -18,7 +18,7 @@ import {
 import { getFundingSource } from '../scaffolding/funding';
 import { getUnifiedPublicKey } from '@frequency-chain/ethereum-utils';
 
-const FUNDS_AMOUNT: bigint = 50n * DOLLARS;
+const FUNDS_AMOUNT: bigint = 100n * DOLLARS;
 let fundingSource: KeyringPair;
 
 describe('Capacity Transactions Batch', function () {

e2e/miscellaneous/utilityBatch.test.ts

@@ -7,6 +7,7 @@ import { getFundingSource } from '../scaffolding/funding';
 import { getUnifiedAddress } from '@frequency-chain/ethereum-utils';
 
 let fundingSource: KeyringPair;
+const FUNDS_AMOUNT = 10n * DOLLARS;
 
 describe('Utility Batch Filtering', function () {
   let sender: KeyringPair;
@@ -17,8 +18,8 @@ describe('Utility Batch Filtering', function () {
   });
 
   beforeEach(async function () {
-    sender = await createAndFundKeypair(fundingSource, 5n * DOLLARS, 'utility-sender');
-    recipient = await createAndFundKeypair(fundingSource, 5n * DOLLARS, 'utility-recipient');
+    sender = await createAndFundKeypair(fundingSource, FUNDS_AMOUNT, 'utility-sender');
+    recipient = await createAndFundKeypair(fundingSource, FUNDS_AMOUNT, 'utility-recipient');
   });
 
   it('should successfully execute ✅ batch with allowed calls', async function () {

e2e/msa/addKeyLowCost.ethereum.test.ts

@@ -29,8 +29,8 @@ describe('adding an Ethereum key for low cost', function () {
   before(async function () {
     fundingSource = await getFundingSource(import.meta.url);
     providerKeys = await createKeys('KeyAdder');
-    providerMsaId = await createMsaAndProvider(fundingSource, providerKeys, 'KeyAdder', 10n * CENTS);
-    await stakeToProvider(fundingSource, fundingSource, providerMsaId, 6n * DOLLARS);
+    providerMsaId = await createMsaAndProvider(fundingSource, providerKeys, 'KeyAdder', 30n * CENTS);
+    await stakeToProvider(fundingSource, fundingSource, providerMsaId, 18n * DOLLARS);
   });
 
   // create a delegator MSA account with new keys,
@@ -39,7 +39,7 @@ describe('adding an Ethereum key for low cost', function () {
   // return the new keys, the resulting payload, and both signatures.
   async function generateAddKeyCallParams() {
     const ethereumKeyringPair = await createKeys('Ethereum', 'ethereum');
-    const [delegatorMsaId, delegatorKeys] = await createMsa(fundingSource, 10n * CENTS);
+    const [delegatorMsaId, delegatorKeys] = await createMsa(fundingSource, 20n * CENTS);
     const { addKeyPayload, delegatorSig, newSig } = await generateAddKeyCallParamsUsingKeys(
       delegatorKeys,
       delegatorMsaId,
@@ -100,7 +100,7 @@ describe('adding an Ethereum key for low cost', function () {
     assertEvent(eventMap, 'msa.PublicKeyAdded');
     const capacityFee = ExtrinsicHelper.getCapacityFee(eventMap);
     assert(capacityFee > 0);
-    assert(capacityFee < 1_320_000n); // ~1.3 CENTS
+    assert(capacityFee < 3_000_000n, `should be ~3 CENTS but it's ${capacityFee}`);
 
     // add another key; this should cost a lot more
     const thirdKeyEth = await createKeys('Eth2', 'ethereum');
@@ -124,9 +124,9 @@ describe('adding an Ethereum key for low cost', function () {
     const { eventMap: eventMap2 } = await addThirdKeyOp.payWithCapacity();
     assertEvent(eventMap2, 'msa.PublicKeyAdded');
     const thirdKeyCapacityFee = ExtrinsicHelper.getCapacityFee(eventMap2);
-    // 4260363n vs
-    // 1278109n
+    // 9708334n vs
+    // 2912500n
     assert(thirdKeyCapacityFee > capacityFee);
-    assert(thirdKeyCapacityFee < 5n * CENTS);
+    assert(thirdKeyCapacityFee < 10n * CENTS);
   });
 });

e2e/msa/msaKeyManagementDelete.test.ts

@@ -17,19 +17,24 @@ import { ethereumAddressToKeyringPair, getUnifiedPublicKey } from '@frequency-ch
 import { H160 } from '@polkadot/types/interfaces';
 
 let fundingSource: KeyringPair;
+const FUNDS_AMOUNT = 5n * DOLLARS;
 
 describe('MSA Key management: delete keys and retire', function () {
   let keys: KeyringPair;
   let secondaryKey: KeyringPair;
   let msaId: u64;
   let msaAccountId: H160;
 
+  // retiring
+  let retiringMsaKey: KeyringPair;
+  let retiringMsaId: u64;
+  let retiringMsaAccountId: H160;
+
   before(async function () {
     fundingSource = await getFundingSource(import.meta.url);
     // Generates a msa with two control keys
     // Fund all the different keys
-    [keys, secondaryKey] = await createAndFundKeypairs(fundingSource, ['keys', 'secondaryKey'], 2n * DOLLARS);
-
+    [keys, secondaryKey] = await createAndFundKeypairs(fundingSource, ['keys', 'secondaryKey'], FUNDS_AMOUNT);
     const { target } = await ExtrinsicHelper.createMsa(keys).signAndSend();
     assert.notEqual(target?.data.msaId, undefined, 'MSA Id not in expected event');
     msaId = target!.data.msaId;
@@ -40,7 +45,7 @@ describe('MSA Key management: delete keys and retire', function () {
     const fundingOp = ExtrinsicHelper.transferFunds(
       fundingSource,
       ethereumAddressToKeyringPair(msaAccountId),
-      1n * DOLLARS
+      3n * DOLLARS
     );
     const { target: fundingEvent } = await fundingOp.signAndSend();
     assert.notEqual(fundingEvent, undefined, 'should have funded MSA account');
@@ -56,51 +61,62 @@ describe('MSA Key management: delete keys and retire', function () {
     const { target: event } = await op.signAndSend();
     assert.notEqual(event, undefined, 'should have added public key');
 
+    // setup retiring msa and keys
+    [retiringMsaKey] = await createAndFundKeypairs(fundingSource, ['retriringMsaKey'], FUNDS_AMOUNT);
+    const { target: target2 } = await ExtrinsicHelper.createMsa(retiringMsaKey).signAndSend();
+    assert.notEqual(target2?.data.msaId, undefined, 'MSA Id not in expected event');
+    retiringMsaId = target2!.data.msaId;
+
+    ({ accountId: retiringMsaAccountId } =
+      await ExtrinsicHelper.apiPromise.call.msaRuntimeApi.getEthereumAddressForMsaId(retiringMsaId));
+    const fundingOp2 = ExtrinsicHelper.transferFunds(
+      fundingSource,
+      ethereumAddressToKeyringPair(retiringMsaAccountId),
+      3n * DOLLARS
+    );
+    const { target: fundingEvent2 } = await fundingOp2.signAndSend();
+    assert.notEqual(fundingEvent2, undefined, 'should have funded MSA account');
+
     // Make sure we are finalized before all the tests
     await ExtrinsicHelper.waitForFinalization();
   });
 
-  it('should disallow retiring an MSA with more than one key authorized', async function () {
+  it('check all different errors for retiring msa', async function () {
+    // should disallow retiring an MSA with more than one key authorized
     const retireOp = ExtrinsicHelper.retireMsa(keys);
     await assert.rejects(retireOp.signAndSend('current'), {
       name: 'RpcError',
       message: /Custom error: 3/,
     });
-  });
 
-  it('should fail to delete public key for self', async function () {
+    // should fail to delete public key for self
     const op = ExtrinsicHelper.deletePublicKey(keys, getUnifiedPublicKey(keys));
     await assert.rejects(op.signAndSend('current'), {
       name: 'RpcError',
       message: /Custom error: 4/,
     });
-  });
 
-  it("should fail to delete key if not authorized for key's MSA", async function () {
-    const [providerKeys] = await createProviderKeysAndId(fundingSource, 1n * DOLLARS, false);
-    const op = ExtrinsicHelper.deletePublicKey(providerKeys, getUnifiedPublicKey(keys));
-    await assert.rejects(op.signAndSend('current'), {
+    // should test for 'NoKeyExists' error
+    const key2 = createKeys('nothing key');
+    const op2 = ExtrinsicHelper.deletePublicKey(keys, getUnifiedPublicKey(key2));
+    await assert.rejects(op2.signAndSend('current'), {
       name: 'RpcError',
-      message: /Custom error: 5/,
+      message: /Custom error: 1/,
     });
-  });
 
-  it("should test for 'NoKeyExists' error", async function () {
-    const key = createKeys('nothing key');
-    const op = ExtrinsicHelper.deletePublicKey(keys, getUnifiedPublicKey(key));
-    await assert.rejects(op.signAndSend('current'), {
+    // should fail to delete key if not authorized for key's MSA
+    const [providerKeys1] = await createProviderKeysAndId(fundingSource, 2n * DOLLARS, false);
+    const op3 = ExtrinsicHelper.deletePublicKey(providerKeys1, getUnifiedPublicKey(keys));
+    await assert.rejects(op3.signAndSend('current'), {
       name: 'RpcError',
-      message: /Custom error: 1/,
+      message: /Custom error: 5/,
     });
-  });
 
-  it('should delete secondary key', async function () {
-    const op = ExtrinsicHelper.deletePublicKey(keys, getUnifiedPublicKey(secondaryKey));
-    const { target: event } = await op.signAndSend();
-    assert.notEqual(event, undefined, 'should have returned PublicKeyDeleted event');
-  });
+    // should delete secondary key and should fail to retire MSA if MSA holds tokens
+    const op4 = ExtrinsicHelper.deletePublicKey(keys, getUnifiedPublicKey(secondaryKey));
+    const { target: event4 } = await op4.signAndSend();
+    assert.notEqual(event4, undefined, 'should have returned PublicKeyDeleted event');
 
-  it('should fail to retire MSA if MSA holds tokens', async function () {
     // Make sure we are finalized removing before trying to retire
     await ExtrinsicHelper.waitForFinalization();
 
@@ -111,22 +127,21 @@ describe('MSA Key management: delete keys and retire', function () {
     });
   });
 
-  it('should allow retiring MSA after additional keys have been deleted and tokens withdran', async function () {
+  it.skip('should allow retiring MSA after additional keys have been deleted and tokens withdran', async function () {
     // Withdraw tokens from MSA account
     const receiverKeys = createKeys('receiver keys');
     const payload = await generateAuthorizedKeyPayload({
       discriminant: 'AuthorizedKeyData',
-      msaId,
+      msaId: retiringMsaId,
       authorizedPublicKey: getUnifiedPublicKey(receiverKeys),
     });
     const payloadToSign = ExtrinsicHelper.api.registry.createType('PalletMsaAuthorizedKeyData', payload);
-    const ownerSig = signPayloadSr25519(keys, payloadToSign);
-    const drainMsaOp = ExtrinsicHelper.withdrawTokens(receiverKeys, keys, ownerSig, payload);
+    const ownerSig = signPayloadSr25519(retiringMsaKey, payloadToSign);
+    const drainMsaOp = ExtrinsicHelper.withdrawTokens(receiverKeys, retiringMsaKey, ownerSig, payload);
     const { target: withdrawTransferEvent } = await drainMsaOp.signAndSend();
     assert.notEqual(withdrawTransferEvent, undefined, 'should have withdrawn tokens from MSA account');
 
-    const retireMsaOp = ExtrinsicHelper.retireMsa(keys);
-
+    const retireMsaOp = ExtrinsicHelper.retireMsa(retiringMsaKey);
     // Make sure we are finalized removing before trying to retire
     await ExtrinsicHelper.waitForFinalization();
 

e2e/msa/msaTokens.test.ts

@@ -154,13 +154,13 @@ describe('MSAs Holding Tokens', function () {
 
     before(async function () {
       // Setup an MSA with tokens
-      msaKeys = await createAndFundKeypair(fundingSource, 5n * CENTS, undefined, undefined, 'ethereum');
+      msaKeys = await createAndFundKeypair(fundingSource, 10n * CENTS, undefined, undefined, 'ethereum');
       let { target } = await ExtrinsicHelper.createMsa(msaKeys).signAndSend();
       assert.notEqual(target?.data.msaId, undefined, 'MSA Id not in expected event');
       msaId = target!.data.msaId;
 
       // Setup another MSA control key
-      otherMsaKeys = await createAndFundKeypair(fundingSource, 5n * CENTS, undefined, undefined, 'ethereum');
+      otherMsaKeys = await createAndFundKeypair(fundingSource, 10n * CENTS, undefined, undefined, 'ethereum');
       ({ target } = await ExtrinsicHelper.createMsa(otherMsaKeys).signAndSend());
       assert.notEqual(target?.data.msaId, undefined, 'MSA Id not in expected event');