Update config tests to use a single account

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cerc-io/registry-sdk",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "git@github.com:cerc-io/registry-sdk.git",

src/auction.test.ts

@@ -16,7 +16,7 @@ const auctionTests = (numBidders = 3) => {
   beforeAll(async () => {
     console.log('Running auction tests with num bidders', numBidders);
 
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
   });
 
   test('Setup bidder accounts', async () => {

src/bond.test.ts

@@ -21,7 +21,7 @@ const bondTests = () => {
   };
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
   });
 
   test('Create bond.', async () => {
@@ -54,15 +54,20 @@ const bondTests = () => {
     test('Query bonds.', async () => {
       const bonds = await registry.queryBonds();
       expect(bonds).toBeDefined();
-      const bond = bonds.filter((bond: any) => bond.id === bond1.id);
+
-      expect(bond).toBeDefined();
+      const filteredBonds = bonds.filter((bond: any) => bond.id === bond1.id);
+      expect(filteredBonds).toHaveLength(1);
+      expect(filteredBonds[0]).toMatchObject({ id: bond1.id, owner: bond1.owner });
     });
 
     test('Query bonds by owner.', async () => {
-      const bonds = await registry.queryBonds({ owner: bond1.owner });
+      const [result] = await registry.queryBondsByOwner([bond1.owner]);
-      expect(bonds).toBeDefined();
+      expect(result).toBeDefined();
-      const bond = bonds.filter((bond: any) => bond.id === bond1.id);
+      expect(result.bonds).toBeDefined();
-      expect(bond).toBeDefined();
+
+      const filteredBonds = result.bonds.filter((bond: any) => bond.id === bond1.id);
+      expect(filteredBonds).toHaveLength(1);
+      expect(filteredBonds[0]).toMatchObject({ id: bond1.id, owner: bond1.owner });
     });
 
     test('Refill bond.', async () => {

src/config.test.ts

@@ -0,0 +1,103 @@
+import { GasPrice } from '@cosmjs/stargate';
+
+import { Account } from './account';
+import { DENOM } from './constants';
+import { Registry } from './index';
+import { createTestAccounts, getConfig } from './testing/helper';
+
+const { chainId, rpcEndpoint, gqlEndpoint, privateKey, fee } = getConfig();
+
+jest.setTimeout(90 * 1000);
+
+const configTests = () => {
+  let registry: Registry;
+  let testAccount: Account;
+
+  beforeAll(async () => {
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
+
+    // Fund a new account for the test
+    [testAccount] = await createTestAccounts(1);
+    await registry.sendCoins({ denom: DENOM, amount: '10000000', destinationAddress: testAccount.address }, privateKey, fee);
+  });
+
+  test('StdFee fees with gas price not set', async () => {
+    const testFees = {
+      amount: [{ denom: 'alnt', amount: '400000' }],
+      gas: '400000'
+    };
+
+    // Send a bond creation tx
+    await registry.createBond({ denom: DENOM, amount: '100000' }, testAccount.getPrivateKey(), testFees);
+
+    // Check that bond gets created
+    const [result] = await registry.queryBondsByOwner([testAccount.address]);
+    expect(result.bonds).toHaveLength(1);
+  });
+
+  test('StdFee fees with gas price set', async () => {
+    const testFees = {
+      amount: [{ denom: 'alnt', amount: '400000' }],
+      gas: '400000'
+    };
+
+    // Set gas price lower than min gas price
+    const testGasPrice = GasPrice.fromString(String('0.00001alnt'));
+    const registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId, gasPrice: testGasPrice });
+
+    // Send a bond creation tx
+    await registry.createBond({ denom: DENOM, amount: '100000' }, testAccount.getPrivateKey(), testFees);
+
+    // Check that bond gets created (gas price ignored)
+    const [result] = await registry.queryBondsByOwner([testAccount.address]);
+    expect(result.bonds).toHaveLength(2);
+  });
+
+  test('Gas price with fees not set (default gas estimation multiplier)', async () => {
+    // Set gas price
+    const testGasPrice = GasPrice.fromString('1alnt');
+    const registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId, gasPrice: testGasPrice });
+
+    // Send a bond creation tx
+    await registry.createBond({ denom: DENOM, amount: '100000' }, testAccount.getPrivateKey());
+
+    // Check that bond gets created (gas price ignored)
+    const [result] = await registry.queryBondsByOwner([testAccount.address]);
+    expect(result.bonds).toHaveLength(3);
+  });
+
+  test('Gas price with fees set (fees as the gas estimation multiplier)', async () => {
+    const testFees = 2.1;
+
+    // Set gas price
+    const testGasPrice = GasPrice.fromString('1alnt');
+    const registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId, gasPrice: testGasPrice });
+
+    // Send a bond creation tx
+    await registry.createBond({ denom: DENOM, amount: '100000' }, testAccount.getPrivateKey(), testFees);
+
+    // Check that bond gets created (gas price ignored)
+    const [result] = await registry.queryBondsByOwner([testAccount.address]);
+    expect(result.bonds).toHaveLength(4);
+  });
+
+  test('Error on fees and gas price both not set', async () => {
+    const errorMsg = 'Gas price must be set in the client options when auto gas is used';
+
+    // Create registry without gasPrice
+    const registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
+
+    // Send a bond creation tx
+    try {
+      await registry.createBond({ denom: DENOM, amount: '100000' }, testAccount.getPrivateKey());
+    } catch (error: any) {
+      expect(error.toString()).toContain(errorMsg);
+    }
+
+    // Check that bond doesn't get created
+    const [result] = await registry.queryBondsByOwner([testAccount.address]);
+    expect(result.bonds).toHaveLength(4);
+  });
+};
+
+describe('Config', configTests);

src/constants.ts

@@ -1 +1,4 @@
 export const DENOM = 'alnt';
+export const DEFAULT_CHAIN_ID = 'laconic_9000-1';
+
+export const DEFAULT_GAS_ESTIMATION_MULTIPLIER = 2;

src/index.test.ts

@@ -1,7 +1,7 @@
 import { Account } from './account';
 import { DENOM } from './constants';
 import { Registry } from './index';
-import { getConfig } from './testing/helper';
+import { createTestAccounts, getConfig } from './testing/helper';
 
 const { chainId, rpcEndpoint, gqlEndpoint, privateKey, fee } = getConfig();
 
@@ -11,7 +11,7 @@ const registryTests = () => {
   let registry: Registry;
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
   });
 
   test('Get account info.', async () => {
@@ -43,6 +43,40 @@ const registryTests = () => {
     expect(type).toBe(DENOM);
     expect(quantity).toBe('10000');
   });
+
+  describe('Batch txs', () => {
+    let accounts: Account[];
+
+    beforeAll(async () => {
+      // Fund 5 new accounts for the test
+      accounts = await createTestAccounts(5);
+      for (let i = 0; i < accounts.length; i++) {
+        await registry.sendCoins({ denom: DENOM, amount: '1000000', destinationAddress: accounts[i].address }, privateKey, fee);
+      }
+    });
+
+    test('Multiple txs get included in a block.', async () => {
+      // Send a bond creation tx from each account (send from different accounts to avoid sequence errors)
+      await Promise.all(accounts.map((account) =>
+        registry.createBond({ denom: DENOM, amount: '100000' }, account.getPrivateKey(), fee)
+      ));
+
+      const laconicClient = await registry.getLaconicClient(accounts[0]);
+      const bondCreationTxHeights = await Promise.all(accounts.map(async (account) => {
+        // Get the bond creation tx for each account
+        const [tx] = await laconicClient.searchTx(`message.sender='${account.address}' AND message.action='/cerc.bond.v1.MsgCreateBond'`);
+        return tx.height;
+      }));
+
+      bondCreationTxHeights.forEach((txHeight, i) => {
+        console.log('tx', accounts[i].address, txHeight);
+      });
+
+      // Check that all txs are within two blocks
+      const expectedBlockHeight = bondCreationTxHeights.sort()[0];
+      expect(bondCreationTxHeights.every(txHeight => txHeight === expectedBlockHeight || txHeight === expectedBlockHeight + 1)).toBe(true);
+    });
+  });
 };
 
 describe('Registry', registryTests);

src/index.ts

@@ -1,6 +1,6 @@
 import { sha256 } from 'js-sha256';
 
-import { DeliverTxResponse, StdFee } from '@cosmjs/stargate';
+import { DeliverTxResponse, StdFee, GasPrice } from '@cosmjs/stargate';
 
 import { RegistryClient } from './registry-client';
 import { Account } from './account';
@@ -31,8 +31,7 @@ import { Coin } from './proto/cosmos/base/v1beta1/coin';
 import { MsgCancelBondResponse, MsgCreateBondResponse, MsgRefillBondResponse, MsgWithdrawBondResponse } from './proto/cerc/bond/v1/tx';
 import { MsgOnboardParticipantResponse } from './proto/cerc/onboarding/v1/tx';
 import { MsgSendResponse } from './proto/cosmos/bank/v1beta1/tx';
-
+import { DEFAULT_CHAIN_ID, DEFAULT_GAS_ESTIMATION_MULTIPLIER } from './constants';
-export const DEFAULT_CHAIN_ID = 'laconic_9000-1';
 
 /**
  * Create an auction bid.
@@ -60,19 +59,26 @@ export const createBid = async (chainId: string, auctionId: string, bidderAddres
   };
 };
 
+interface RegistryOptions {
+  chainId?: string
+  gasPrice?: GasPrice
+}
+
 export class Registry {
   _endpoints: { [key: string]: string };
   _chainID: string;
   _client: RegistryClient;
+  _gasPrice?: GasPrice;
 
-  constructor (gqlUrl: string, rpcUrl = '', chainId: string = DEFAULT_CHAIN_ID) {
+  constructor (gqlUrl: string, rpcUrl = '', options?: RegistryOptions) {
     this._endpoints = {
       rpc: rpcUrl,
       gql: gqlUrl
     };
 
     this._client = new RegistryClient(gqlUrl, rpcUrl);
-    this._chainID = chainId;
+    this._chainID = options?.chainId ?? DEFAULT_CHAIN_ID;
+    this._gasPrice = options?.gasPrice;
   }
 
   /**
@@ -125,7 +131,7 @@ export class Registry {
   async setRecord (
     { privateKey, record, bondId }: { privateKey: string, record: any, bondId: string },
     transactionPrivateKey: string,
-    fee: StdFee
+    fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER
   ) {
     const account = new Account(Buffer.from(transactionPrivateKey, 'hex'));
     await account.init();
@@ -140,7 +146,7 @@ export class Registry {
   /**
    * Send coins.
    */
-  async sendCoins ({ amount, denom, destinationAddress }: MessageMsgSendCoins, privateKey: string, fee: StdFee) {
+  async sendCoins ({ amount, denom, destinationAddress }: MessageMsgSendCoins, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -186,16 +192,23 @@ export class Registry {
   }
 
   /**
-   * Query bonds by attributes.
+   * Query bonds.
    */
-  async queryBonds (attributes = {}) {
+  async queryBonds () {
-    return this._client.queryBonds(attributes);
+    return this._client.queryBonds();
+  }
+
+  /**
+ * Query bonds by owner(s).
+ */
+  async queryBondsByOwner (owners: string[]) {
+    return this._client.queryBondsByOwner(owners);
   }
 
   /**
    * Create bond.
    */
-  async createBond ({ denom, amount }: MessageMsgCreateBond, privateKey: string, fee: StdFee): Promise<MsgCreateBondResponse> {
+  async createBond ({ denom, amount }: MessageMsgCreateBond, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER): Promise<MsgCreateBondResponse> {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -211,7 +224,7 @@ export class Registry {
   /**
    * Refill bond.
    */
-  async refillBond ({ denom, amount, id }: MessageMsgRefillBond, privateKey: string, fee: StdFee): Promise<MsgRefillBondResponse> {
+  async refillBond ({ denom, amount, id }: MessageMsgRefillBond, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER): Promise<MsgRefillBondResponse> {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -228,7 +241,7 @@ export class Registry {
   /**
    * Withdraw (from) bond.
    */
-  async withdrawBond ({ denom, amount, id }: MessageMsgWithdrawBond, privateKey: string, fee: StdFee): Promise<MsgWithdrawBondResponse> {
+  async withdrawBond ({ denom, amount, id }: MessageMsgWithdrawBond, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER): Promise<MsgWithdrawBondResponse> {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -245,7 +258,7 @@ export class Registry {
   /**
    * Cancel bond.
    */
-  async cancelBond ({ id }: MessageMsgCancelBond, privateKey: string, fee: StdFee): Promise<MsgCancelBondResponse> {
+  async cancelBond ({ id }: MessageMsgCancelBond, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER): Promise<MsgCancelBondResponse> {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -260,7 +273,7 @@ export class Registry {
   /**
    * Associate record with bond.
    */
-  async associateBond ({ bondId, recordId }: MessageMsgAssociateBond, privateKey: string, fee: StdFee) {
+  async associateBond ({ bondId, recordId }: MessageMsgAssociateBond, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -276,7 +289,7 @@ export class Registry {
   /**
    * Dissociate record from bond.
    */
-  async dissociateBond ({ recordId }: MessageMsgDissociateBond, privateKey: string, fee: StdFee) {
+  async dissociateBond ({ recordId }: MessageMsgDissociateBond, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -291,7 +304,7 @@ export class Registry {
   /**
    * Dissociate all records from bond.
    */
-  async dissociateRecords ({ bondId }: MessageMsgDissociateRecords, privateKey: string, fee: StdFee) {
+  async dissociateRecords ({ bondId }: MessageMsgDissociateRecords, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -306,7 +319,7 @@ export class Registry {
   /**
    * Reassociate records (switch bond).
    */
-  async reassociateRecords ({ newBondId, oldBondId }: MessageMsgReAssociateRecords, privateKey: string, fee: StdFee) {
+  async reassociateRecords ({ newBondId, oldBondId }: MessageMsgReAssociateRecords, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -322,7 +335,7 @@ export class Registry {
   /**
    * Reserve authority.
    */
-  async reserveAuthority ({ name, owner }: { name: string, owner?: string }, privateKey: string, fee: StdFee) {
+  async reserveAuthority ({ name, owner }: { name: string, owner?: string }, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -338,7 +351,7 @@ export class Registry {
   /**
    * Set authority bond.
    */
-  async setAuthorityBond ({ bondId, name }: MessageMsgSetAuthorityBond, privateKey: string, fee: StdFee) {
+  async setAuthorityBond ({ bondId, name }: MessageMsgSetAuthorityBond, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -354,7 +367,7 @@ export class Registry {
   /**
    * Commit auction bid.
    */
-  async commitBid ({ auctionId, commitHash }: MessageMsgCommitBid, privateKey: string, fee: StdFee) {
+  async commitBid ({ auctionId, commitHash }: MessageMsgCommitBid, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -370,7 +383,7 @@ export class Registry {
   /**
    * Reveal auction bid.
    */
-  async revealBid ({ auctionId, reveal }: MessageMsgRevealBid, privateKey: string, fee: StdFee) {
+  async revealBid ({ auctionId, reveal }: MessageMsgRevealBid, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -406,7 +419,7 @@ export class Registry {
   /**
    * Set name (LRN) to record ID (CID).
    */
-  async setName ({ cid, lrn }: MessageMsgSetName, privateKey: string, fee: StdFee) {
+  async setName ({ cid, lrn }: MessageMsgSetName, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -429,7 +442,7 @@ export class Registry {
   /**
    * Delete name (LRN) mapping.
    */
-  async deleteName ({ lrn }: MessageMsgDeleteName, privateKey: string, fee: StdFee) {
+  async deleteName ({ lrn }: MessageMsgDeleteName, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER) {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -440,14 +453,10 @@ export class Registry {
     );
   }
 
-  async getLaconicClient (account: Account) {
-    return LaconicClient.connectWithSigner(this._endpoints.rpc, account.wallet);
-  }
-
   /**
    * Onboard participant.
   */
-  async onboardParticipant ({ ethPayload, ethSignature, role, kycId }: MessageMsgOnboardParticipant, privateKey: string, fee: StdFee): Promise<MsgOnboardParticipantResponse> {
+  async onboardParticipant ({ ethPayload, ethSignature, role, kycId }: MessageMsgOnboardParticipant, privateKey: string, fee: StdFee | number = DEFAULT_GAS_ESTIMATION_MULTIPLIER): Promise<MsgOnboardParticipantResponse> {
     const account = new Account(Buffer.from(privateKey, 'hex'));
     await account.init();
     const laconicClient = await this.getLaconicClient(account);
@@ -482,9 +491,18 @@ export class Registry {
   async getParticipantByNitroAddress (nitroAddress: string) {
     return this._client.getParticipantByNitroAddress(nitroAddress);
   }
+
+  async getLaconicClient (account: Account) {
+    return LaconicClient.connectWithSigner(
+      this._endpoints.rpc,
+      account.wallet,
+      { gasPrice: this._gasPrice }
+    );
+  }
 }
 
 export { Account };
 export { LaconicClient };
+export * from './constants';
 export * from './types/cerc/bond/message';
 export * from './types/cerc/onboarding/message';

src/nameservice-expiry.test.ts

@@ -21,7 +21,7 @@ const nameserviceExpiryTests = () => {
   let recordExpiryTime: Date;
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
 
     // Create bond.
     bondId = await registry.getNextBondId(privateKey);

src/naming.test.ts

@@ -34,7 +34,7 @@ const namingTests = () => {
   let account: CosmosAccount;
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
 
     // Create bond.
     bondId = await registry.getNextBondId(privateKey);

src/onboarding.test.ts

@@ -20,7 +20,7 @@ const onboardingEnabledTests = () => {
   let expectedParticipants: Participant[] = [];
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
 
     const mnemonic = Account.generateMnemonic();
     ethWallet = Wallet.fromMnemonic(mnemonic);
@@ -76,7 +76,7 @@ const onboardingDisabledTests = () => {
   let ethWallet: Wallet;
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
   });
 
   test('Error on onboarding attempt.', async () => {

src/registry-client.ts

@@ -425,11 +425,11 @@ export class RegistryClient {
   }
 
   /**
-   * Get bonds by attributes.
+   * Get bonds.
    */
-  async queryBonds (attributes = {}) {
+  async queryBonds () {
-    const query = `query ($attributes: [KeyValueInput!]) {
+    const query = `query {
-      queryBonds(attributes: $attributes) {
+      queryBonds {
         id
         owner
         balance {
@@ -439,11 +439,32 @@ export class RegistryClient {
       }
     }`;
 
+    return RegistryClient.getResult(this._graph(query)({}), 'queryBonds');
+  }
+
+  /**
+   * Get bonds by owner(s).
+   */
+  async queryBondsByOwner (ownerAddresses: string[]) {
+    const query = `query ($ownerAddresses: [String!]) {
+      queryBondsByOwner(ownerAddresses: $ownerAddresses) {
+        owner
+        bonds {
+          id
+          owner
+          balance {
+            type
+            quantity
+          }
+        }
+      }
+    }`;
+
     const variables = {
-      attributes: Util.toGQLAttributes(attributes)
+      ownerAddresses
     };
 
-    return RegistryClient.getResult(this._graph(query)(variables), 'queryBonds');
+    return RegistryClient.getResult(this._graph(query)(variables), 'queryBondsByOwner');
   }
 
   /**

src/sdk.test.ts

@@ -16,7 +16,7 @@ describe('Querying', () => {
   let bondId: string;
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
 
     bondId = await registry.getNextBondId(privateKey);
     await registry.createBond({ denom: DENOM, amount: '1000000000' }, privateKey, fee);

src/testing/helper.ts

@@ -2,7 +2,8 @@ import assert from 'assert';
 import yaml from 'node-yaml';
 import semver from 'semver';
 
-import { DEFAULT_CHAIN_ID } from '../index';
+import { Account } from '../index';
+import { DEFAULT_CHAIN_ID } from '../constants';
 
 export const ensureUpdatedConfig = async (path: string) => {
   const conf = await yaml.read(path);
@@ -33,3 +34,16 @@ export const getConfig = () => {
     }
   };
 };
+
+export const createTestAccounts = async (numAccounts: number): Promise<Account[]> => {
+  const accounts: Account[] = [];
+
+  for (let i = 0; i < numAccounts; i++) {
+    const mnemonic = Account.generateMnemonic();
+    const account = await Account.generateFromMnemonic(mnemonic);
+    await account.init();
+    accounts.push(account);
+  }
+
+  return accounts;
+};

src/util.test.ts

@@ -19,7 +19,7 @@ const utilTests = () => {
   let watcherId: string;
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
 
     // Create bond.
     bondId = await registry.getNextBondId(privateKey);