Rename cns to registry in CLI (#57)

Part of https://www.notion.so/Create-laconic-registry-SDK-d3a636d4aba44f7cbba3bd99b7146811

Co-authored-by: neeraj <neeraj.rtly@gmail.com>
Reviewed-on: cerc-io/laconic-registry-cli#57
Co-authored-by: Nabarun <nabarun@deepstacksoft.com>
Co-committed-by: Nabarun <nabarun@deepstacksoft.com>

src/cmds/registry-cmds/account-cmds/get.ts

@@ -11,11 +11,11 @@ export const desc = 'Get account.';
 export const handler = async (argv: Arguments) => {
   let address = argv.address as string;
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   if (!address && privateKey) {
     address = new Account(Buffer.from(privateKey, 'hex')).address;

src/cmds/registry-cmds/auction-cmds/bid-cmds/commit.ts

@@ -21,12 +21,12 @@ export const handler = async (argv: Arguments) => {
   assert(quantity, 'Invalid token quantity.');
   assert(denom, 'Invalid token type.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const account = new Account(Buffer.from(privateKey, 'hex'));
   await account.init();
@@ -41,7 +41,7 @@ export const handler = async (argv: Arguments) => {
   fs.writeFileSync(revealFilePath, JSON.stringify(reveal, undefined, 2));
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
 
   const result = await registry.commitBid({ auctionId, commitHash }, privateKey, fee);
   const revealFile = `{"reveal_file":"${revealFilePath}"}`;

src/cmds/registry-cmds/auction-cmds/bid-cmds/reveal.ts

@@ -16,15 +16,15 @@ export const handler = async (argv: Arguments) => {
   assert(auctionId, 'Invalid auction ID.');
   assert(filePath, 'Invalid reveal file path.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
 
   const reveal = fs.readFileSync(path.resolve(filePath));
   const result = await registry.revealBid({ auctionId, reveal: reveal.toString('hex') }, privateKey, fee);

src/cmds/registry-cmds/auction-cmds/get.ts

@@ -12,11 +12,11 @@ export const handler = async (argv: Arguments) => {
   const { id, config } = argv;
   assert(id, 'Invalid auction ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
   const result = await registry.getAuctionsByIds([id as string]);

src/cmds/registry-cmds/authority-cmds/bond-cmds/set.ts

@@ -14,15 +14,15 @@ export const handler = async (argv: Arguments) => {
   assert(name, 'Invalid authority name.');
   assert(bondId, 'Invalid Bond ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.setAuthorityBond({ name, bondId }, privateKey, fee);
   const success = '{"success": true}';
 

src/cmds/registry-cmds/authority-cmds/reserve.ts

@@ -20,15 +20,15 @@ export const handler = async (argv: Arguments) => {
   const owner = argv.owner as string;
   assert(name, 'Invalid authority name.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.reserveAuthority({ name, owner }, privateKey, fee);
 
   const success = '{"success": true}';

src/cmds/registry-cmds/authority-cmds/whois.ts

@@ -12,11 +12,11 @@ export const handler = async (argv: Arguments) => {
   const name = argv.name as string;
   assert(name, 'Invalid authority name.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
   const result = await registry.lookupAuthorities([name], true);

src/cmds/registry-cmds/bond-cmds/associate.ts

@@ -20,15 +20,15 @@ export const handler = async (argv: Arguments) => {
   assert(id, 'Invalid Record ID.');
   assert(bondId, 'Invalid Bond ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.associateBond({ recordId: id, bondId }, privateKey, fee);
   const success = '{"success": true}';
   txOutput(result, success, argv.output, argv.verbose);

src/cmds/registry-cmds/bond-cmds/cancel.ts

@@ -12,15 +12,15 @@ export const handler = async (argv: Arguments) => {
   const id = argv.id as string;
   assert(id, 'Invalid Bond ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.cancelBond({ id }, privateKey, fee);
   const success = '{"success": true}';
   txOutput(result, success, argv.output, argv.verbose);

src/cmds/registry-cmds/bond-cmds/create.ts

@@ -25,15 +25,15 @@ export const handler = async (argv: Arguments) => {
   assert(denom, 'Invalid Type.');
   assert(amount, 'Invalid Quantity.');
 
-  const { services: { cns: cnsConfig } } = getConfig(config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const bondId = await registry.getNextBondId(privateKey);
   const result = await registry.createBond({ denom, amount }, privateKey, fee);
   const jsonString = `{"bondId":"${bondId}"}`;

src/cmds/registry-cmds/bond-cmds/dissociate.ts

@@ -12,15 +12,15 @@ export const handler = async (argv: Arguments) => {
   const id = argv.id as string;
   assert(id, 'Invalid Record ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.dissociateBond({ recordId: id }, privateKey, fee);
   const success = '{"success": true}';
   txOutput(result, success, argv.output, argv.verbose);

src/cmds/registry-cmds/bond-cmds/get.ts

@@ -12,11 +12,11 @@ export const handler = async (argv: Arguments) => {
   const { id, config } = argv;
   console.assert(id, 'Bond Id is required.');
 
-  const { services: { cns: cnsConfig } } = getConfig(config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
 

src/cmds/registry-cmds/bond-cmds/list.ts

@@ -15,11 +15,11 @@ export const builder = {
 };
 
 export const handler = async (argv: Arguments) => {
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
 

src/cmds/registry-cmds/bond-cmds/records-cmds/dissociate.ts

@@ -18,15 +18,15 @@ export const handler = async (argv: Arguments) => {
   const bondId = argv.bondId as string;
   assert(bondId, 'Invalid Bond ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.dissociateRecords({ bondId }, privateKey, fee);
   const success = '{"success": true}';
   txOutput(result, success, argv.output, argv.verbose);

src/cmds/registry-cmds/bond-cmds/records-cmds/reassociate.ts

@@ -23,15 +23,15 @@ export const handler = async (argv: Arguments) => {
   assert(oldBondId, 'Invalid Old Bond ID.');
   assert(newBondId, 'Invalid New Bond ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.reassociateRecords({ oldBondId, newBondId }, privateKey, fee);
   const success = '{"success": true}';
   txOutput(result, success, argv.output, argv.verbose);

src/cmds/registry-cmds/bond-cmds/refill.ts

@@ -26,15 +26,15 @@ export const handler = async (argv: Arguments) => {
   assert(denom, 'Invalid Type.');
   assert(amount, 'Invalid Quantity.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.refillBond({ id, denom, amount }, privateKey, fee);
   const success = '{"success": true}';
   txOutput(result, success, argv.output, argv.verbose);

src/cmds/registry-cmds/bond-cmds/withdraw.ts

@@ -26,15 +26,15 @@ export const handler = async (argv: Arguments) => {
   assert(denom, 'Invalid Type.');
   assert(amount, 'Invalid Quantity.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.withdrawBond({ id, denom, amount }, privateKey, fee);
   const success = '{"success": true}';
   txOutput(result, success, argv.output, argv.verbose);

src/cmds/registry-cmds/name-cmds/delete.ts

@@ -12,15 +12,15 @@ export const handler = async (argv: Arguments) => {
   const name = argv.name as string;
   assert(name, 'Invalid Name.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.deleteName({ lrn: name }, privateKey, fee);
 
   const success = '{"success": true}';

src/cmds/registry-cmds/name-cmds/lookup.ts

@@ -18,11 +18,11 @@ export const handler = async (argv: Arguments) => {
   const name = argv.name as string;
   assert(name, 'Invalid Name.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
   const result = await registry.lookupNames([name], argv.history as boolean);

src/cmds/registry-cmds/name-cmds/resolve.ts

@@ -12,11 +12,11 @@ export const handler = async (argv: Arguments) => {
   const name = argv.name as string;
   assert(name, 'Invalid Name.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
 

src/cmds/registry-cmds/name-cmds/set.ts

@@ -14,15 +14,15 @@ export const handler = async (argv: Arguments) => {
   assert(name, 'Invalid Name.');
   assert(id, 'Invalid Record ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.setName({ lrn: name, cid: id }, privateKey, fee);
 
   const success = '{"success": true}';

src/cmds/registry-cmds/record-cmds/get.ts

@@ -12,11 +12,11 @@ export const handler = async (argv: Arguments) => {
   const { id, config } = argv;
   assert(id, 'Invalid Record ID.');
 
-  const { services: { cns: cnsConfig } } = getConfig(config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
   const result = await registry.getRecordsByIds([id as string]);

src/cmds/registry-cmds/record-cmds/list.ts

@@ -28,8 +28,8 @@ export const builder = {
 };
 
 export const handler = async (argv: Arguments) => {
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
   const { type, name, bondId, owner, all } = argv;
   const filters: any = {};
 
@@ -38,9 +38,9 @@ export const handler = async (argv: Arguments) => {
     filters[String(filterArgs[i]).replace(/^-+/, '')] = filterArgs[i + 1];
   }
 
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
 

src/cmds/registry-cmds/record-cmds/publish.ts

@@ -18,14 +18,14 @@ export const builder = {
 
 export const handler = async (argv: Arguments) => {
   const { txKey, filename, config } = argv;
-  const { services: { cns: cnsConfig } } = getConfig(config as string);
-  const { restEndpoint, gqlEndpoint, userKey, bondId, chainId } = getConnectionInfo(argv, cnsConfig);
+  const { services: { registry: registryConfig } } = getConfig(config as string);
+  const { restEndpoint, gqlEndpoint, userKey, bondId, chainId } = getConnectionInfo(argv, registryConfig);
 
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(userKey, 'Invalid User Key.');
   assert(bondId, 'Invalid Bond ID.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   let file = null;
   if (filename) {
@@ -44,7 +44,7 @@ export const handler = async (argv: Arguments) => {
   }
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   const result = await registry.setRecord({ privateKey: userKey, record, bondId }, txKey || userKey, fee);
 
   txOutput(result, JSON.stringify(result, undefined, 2), argv.output, argv.verbose);

src/cmds/registry-cmds/status.ts

@@ -6,14 +6,14 @@ import { getConfig, getConnectionInfo } from '../../util';
 
 export const command = 'status';
 
-export const desc = 'Get CNS status.';
+export const desc = 'Get registry status.';
 
 export const handler = async (argv: Arguments) => {
-  const { services: { cns } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cns);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
 

src/cmds/registry-cmds/tokens-cmds/send.ts

@@ -26,19 +26,19 @@ export const handler = async (argv: Arguments) => {
   assert(denom, 'Invalid Type.');
   assert(amount, 'Invalid Quantity.');
 
-  const { services: { cns: cnsConfig } } = getConfig(argv.config as string);
-  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
-  assert(restEndpoint, 'Invalid CNS REST endpoint.');
-  assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
+  const { services: { registry: registryConfig } } = getConfig(argv.config as string);
+  const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
+  assert(restEndpoint, 'Invalid registry REST endpoint.');
+  assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
   assert(privateKey, 'Invalid Transaction Key.');
-  assert(chainId, 'Invalid CNS Chain ID.');
+  assert(chainId, 'Invalid registry Chain ID.');
 
   const account = new Account(Buffer.from(privateKey, 'hex'));
   await account.init();
   const fromAddress = account.address;
 
   const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
-  const fee = getGasAndFees(argv, cnsConfig);
+  const fee = getGasAndFees(argv, registryConfig);
   await registry.sendCoins({ denom, amount, destinationAddress }, privateKey, fee);
   const result = await registry.getAccounts([fromAddress, destinationAddress]);
   queryOutput(result, argv.output);

src/cmds/registry.ts

@@ -1,8 +1,8 @@
 import yargs from 'yargs';
 
-export const command = 'cns';
+export const command = 'registry';
 
-export const desc = 'CNS tools';
+export const desc = 'Registry tools';
 
 exports.builder = (yargs: yargs.Argv) => {
   return yargs
@@ -17,7 +17,7 @@ exports.builder = (yargs: yargs.Argv) => {
       gas: { type: 'string' },
       fees: { type: 'string' }
     })
-    .commandDir('cns-cmds')
+    .commandDir('registry-cmds')
     .demandCommand()
     .help();
 };