Add support for using auto fee calculation (#22)

Part of [Create a public laconicd testnet](https://www.notion.so/Create-a-public-laconicd-testnet-896a11bdd8094eff8f1b49c0be0ca3b8)

- Add an option for setting gas price
- Use fees as gas estimation multiplier when `gasPrice` is provided (following `cosmjs` pattern)
  - Default gas estimation multiplier: `2`
- Add a method to query bonds by owners and fix tests
- Add a test for inclusion of batch of txs sent at once in the same block

Co-authored-by: IshaVenikar <ishavenikar7@gmail.com>
Co-authored-by: Nabarun <nabarun@deepstacksoft.com>
Reviewed-on: #22
Co-authored-by: Prathamesh Musale <prathamesh.musale0@gmail.com>
Co-committed-by: Prathamesh Musale <prathamesh.musale0@gmail.com>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cerc-io/registry-sdk",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "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

@@ -1,6 +1,6 @@
 import path from 'path';
 
-import { Registry } from './index';
+import { Account, Registry } from './index';
 import { ensureUpdatedConfig, getConfig } from './testing/helper';
 import { DENOM } from './constants';
 
@@ -13,6 +13,7 @@ jest.setTimeout(90 * 1000);
 
 const bondTests = () => {
   let registry: Registry;
+  let bond0: { id: string, owner: string };
 
   const publishNewWatcherVersion = async (bondId: string) => {
     let watcher = await ensureUpdatedConfig(WATCHER_YML_PATH);
@@ -21,17 +22,19 @@ const bondTests = () => {
   };
 
   beforeAll(async () => {
-    registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
+    registry = new Registry(gqlEndpoint, rpcEndpoint, { chainId });
   });
 
   test('Create bond.', async () => {
     let bondId = await registry.getNextBondId(privateKey);
     expect(bondId).toBeDefined();
     await registry.createBond({ denom: DENOM, amount: BOND_AMOUNT }, privateKey, fee);
+
+    [bond0] = await registry.getBondsByIds([bondId]);
   });
 
   describe('With bond created', () => {
-    let bond1: any;
+    let bond1: { id: string, owner: string };
 
     beforeAll(async () => {
       let bondId1 = await registry.getNextBondId(privateKey);
@@ -61,13 +64,24 @@ const bondTests = () => {
     });
 
     test('Query bonds by owner.', async () => {
-      const [result] = await registry.queryBondsByOwner([bond1.owner]);
-      expect(result).toBeDefined();
-      expect(result.bonds).toBeDefined();
+      const mnenonic = Account.generateMnemonic();
+      const otherAccount = await Account.generateFromMnemonic(mnenonic);
+      await otherAccount.init();
+      await registry.sendCoins({ denom: DENOM, amount: '1000000000000', destinationAddress: otherAccount.address }, privateKey, fee);
 
-      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 });
+      const { id: bondId2 } = await registry.createBond({ denom: DENOM, amount: BOND_AMOUNT }, otherAccount.getPrivateKey(), fee);
+
+      const [owner1Bonds] = await registry.queryBondsByOwners([bond0.owner]);
+      const owner1Bond1 = owner1Bonds.bonds.filter((b: any) => b.id === bond0.id);
+      const owner1Bond2 = owner1Bonds.bonds.filter((b: any) => b.id === bond1.id);
+      expect(owner1Bond1).toBeDefined();
+      expect(owner1Bond2).toBeDefined();
+
+      const [bond2] = await registry.getBondsByIds([bondId2]);
+      const [owner2Bonds] = await registry.queryBondsByOwners([bond2.owner]);
+      expect(owner2Bonds.bonds).toHaveLength(1);
+      const owner2Bond = owner2Bonds.bonds.filter((b: any) => b.id === bondId2);
+      expect(owner2Bond).toBeDefined();
     });
 
     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.queryBondsByOwners([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.queryBondsByOwners([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.queryBondsByOwners([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.queryBondsByOwners([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.queryBondsByOwners([testAccount.address]);
+    expect(result.bonds).toHaveLength(4);
+  });
+};
+
+describe('Config', configTests);

src/constants.ts

@@ -1 +1,2 @@
 export const DENOM = 'alnt';
+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';
-
-export const DEFAULT_CHAIN_ID = 'laconic_9000-1';
+import { DEFAULT_GAS_ESTIMATION_MULTIPLIER } from './constants';
 
 /**
  * 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;
+    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);
@@ -195,14 +201,14 @@ export class Registry {
   /**
  * Query bonds by owner(s).
  */
-  async queryBondsByOwner (owners: string[]) {
-    return this._client.queryBondsByOwner(owners);
+  async queryBondsByOwners (owners: string[]) {
+    return this._client.queryBondsByOwners(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);
@@ -218,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);
@@ -235,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);
@@ -252,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);
@@ -267,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);
@@ -283,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);
@@ -298,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);
@@ -313,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);
@@ -329,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);
@@ -345,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);
@@ -361,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);
@@ -377,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);
@@ -413,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);
@@ -436,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);
@@ -447,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);
@@ -489,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

@@ -447,7 +447,7 @@ export class RegistryClient {
   /**
    * Get bonds by owner(s).
    */
-  async queryBondsByOwner (ownerAddresses: string[]) {
+  async queryBondsByOwners (ownerAddresses: string[]) {
     const query = `query ($ownerAddresses: [String!]) {
       queryBondsByOwner(ownerAddresses: $ownerAddresses) {
         owner

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,9 @@ import assert from 'assert';
 import yaml from 'node-yaml';
 import semver from 'semver';
 
-import { DEFAULT_CHAIN_ID } from '../index';
+import { Account } from '../index';
+
+const DEFAULT_CHAIN_ID = 'laconic_9000-1';
 
 export const ensureUpdatedConfig = async (path: string) => {
   const conf = await yaml.read(path);
@@ -33,3 +35,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);