cerc-io/laconic-registry-cli
19
0
Fork 1
Code Issues 1 Pull Requests 2 Actions Packages Projects Releases 24 Wiki Activity

Rename cns to registry in CLI #57

Merged
nabarun merged 3 commits from deep-stack/laconic-registry-cli:nv-rename-cns into laconic2 2024-03-19 04:42:44 +00:00
Conversation 0 Commits 3 Files Changed 43 +279 -280
43 changed files with 279 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
README.md
View File

@ -1,6 +1,6 @@
# laconic-cns-client # laconic-registry-client
CLI utility written in TS, used to interact with laconicd. Depends on [laconic-sdk](https://github.com/cerc-io/laconic-sdk). CLI utility written in TS, used to interact with laconicd. Depends on [registry-sdk](https://git.vdb.to/cerc-io/registry-sdk).
## Setup ## Setup
@ -18,7 +18,7 @@ Run the chain:
TEST_AUCTION_ENABLED=true ./init.sh TEST_AUCTION_ENABLED=true ./init.sh
``` ```
Registering records in CNS requires an account. To get account private key run: Registering records in registry requires an account. To get account private key run:
```bash ```bash
$ laconicd keys export mykey --unarmored-hex --unsafe $ laconicd keys export mykey --unarmored-hex --unsafe
@ -38,7 +38,7 @@ The `gas` and `fees` can be set to some default values in the config, and can be
Example: Example:
```bash ```bash
$ laconic cns bond create --type aphoton --quantity 1000000000 --gas 200000 --fees 200000aphoton $ laconic registry bond create --type photon --quantity 1000000000 --gas 200000 --fees 200000photon
``` ```
## Operations ## Operations
@ -48,7 +48,7 @@ These commands require a `config.yml` file present in the current working direct
Get node status: Get node status:
```bash ```bash
$ laconic cns status $ laconic registry status
{ {
"version": "0.3.0", "version": "0.3.0",
"node": { "node": {
@ -82,7 +82,7 @@ $ laconic cns status
Get account details: Get account details:
```bash ```bash
$ laconic cns account get --address ethm133y09mveksh76uc99h4rl38nd033tk4e3y2z52 $ laconic registry account get --address ethm133y09mveksh76uc99h4rl38nd033tk4e3y2z52
[ [
{ {
"address": "ethm133y09mveksh76uc99h4rl38nd033tk4e3y2z52", "address": "ethm133y09mveksh76uc99h4rl38nd033tk4e3y2z52",
@ -91,7 +91,7 @@ $ laconic cns account get --address ethm133y09mveksh76uc99h4rl38nd033tk4e3y2z52
"sequence": "37", "sequence": "37",
"balance": [ "balance": [
{ {
"type": "aphoton", "type": "photon",
"quantity": "89998999999999991999799300" "quantity": "89998999999999991999799300"
} }
] ]
@ -102,7 +102,7 @@ $ laconic cns account get --address ethm133y09mveksh76uc99h4rl38nd033tk4e3y2z52
Send tokens: Send tokens:
```bash ```bash
$ laconic cns tokens send --address ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu --type aphoton --quantity 1000000000 $ laconic registry tokens send --address ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu --type photon --quantity 1000000000
[ [
{ {
"address": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8", "address": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
@ -111,7 +111,7 @@ $ laconic cns tokens send --address ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu
"sequence": "16", "sequence": "16",
"balance": [ "balance": [
{ {
"type": "aphoton", "type": "photon",
"quantity": "99998999999999997973999700" "quantity": "99998999999999997973999700"
} }
] ]
@ -123,7 +123,7 @@ $ laconic cns tokens send --address ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu
"sequence": "0", "sequence": "0",
"balance": [ "balance": [
{ {
"type": "aphoton", "type": "photon",
"quantity": "1000000000" "quantity": "1000000000"
} }
] ]
@ -147,7 +147,7 @@ record:
Publish record (see below for commands to create/query bonds): Publish record (see below for commands to create/query bonds):
```bash ```bash
$ laconic cns record publish --filename watcher.yml --bond-id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --gas 250000 $ laconic registry record publish --filename watcher.yml --bond-id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --gas 250000
{ id: 'bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba' } { id: 'bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba' }
``` ```
@ -155,7 +155,7 @@ $ laconic cns record publish --filename watcher.yml --bond-id 58508984500aa2ed18
Get record: Get record:
```bash ```bash
$ laconic cns record get --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba $ laconic registry record get --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba
[ [
{ {
"id": "bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba", "id": "bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba",
@ -196,19 +196,19 @@ $ laconic cns record get --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln
List records: List records:
```bash ```bash
$ laconic cns record list $ laconic registry record list
``` ```
Reserve authority: Reserve authority:
```bash ```bash
$ laconic cns authority reserve laconic $ laconic registry authority reserve laconic
``` ```
Check authority information: Check authority information:
```bash ```bash
$ laconic cns authority whois laconic $ laconic registry authority whois laconic
[ [
{ {
"ownerAddress": "", "ownerAddress": "",
@ -225,15 +225,15 @@ $ laconic cns authority whois laconic
"commitsEndTime": "2022-04-26T11:44:45.679728594", "commitsEndTime": "2022-04-26T11:44:45.679728594",
"revealsEndTime": "2022-04-26T11:45:45.679728594", "revealsEndTime": "2022-04-26T11:45:45.679728594",
"commitFee": { "commitFee": {
"type": "aphoton", "type": "photon",
"quantity": "1000000" "quantity": "1000000"
}, },
"revealFee": { "revealFee": {
"type": "aphoton", "type": "photon",
"quantity": "1000000" "quantity": "1000000"
}, },
"minimumBid": { "minimumBid": {
"type": "aphoton", "type": "photon",
"quantity": "5000000" "quantity": "5000000"
}, },
"winnerAddress": "", "winnerAddress": "",
@ -254,7 +254,7 @@ $ laconic cns authority whois laconic
Get authority auction info: Get authority auction info:
```bash ```bash
$ laconic cns auction get 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 $ laconic registry auction get 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48
[ [
{ {
"id": "0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48", "id": "0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48",
@ -264,15 +264,15 @@ $ laconic cns auction get 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5
"commitsEndTime": "2022-04-26T11:44:45.679728594", "commitsEndTime": "2022-04-26T11:44:45.679728594",
"revealsEndTime": "2022-04-26T11:45:45.679728594", "revealsEndTime": "2022-04-26T11:45:45.679728594",
"commitFee": { "commitFee": {
"type": "aphoton", "type": "photon",
"quantity": "1000000" "quantity": "1000000"
}, },
"revealFee": { "revealFee": {
"type": "aphoton", "type": "photon",
"quantity": "1000000" "quantity": "1000000"
}, },
"minimumBid": { "minimumBid": {
"type": "aphoton", "type": "photon",
"quantity": "5000000" "quantity": "5000000"
}, },
"winnerAddress": "", "winnerAddress": "",
@ -292,7 +292,7 @@ $ laconic cns auction get 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5
Commit an auction bid: Commit an auction bid:
```bash ```bash
$ laconic cns auction bid commit 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 25000000 aphoton $ laconic registry auction bid commit 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 25000000 photon
Reveal file: ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.json Reveal file: ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.json
``` ```
@ -300,37 +300,37 @@ Reveal file: ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.j
Reveal an auction bid: Reveal an auction bid:
```bash ```bash
$ laconic cns auction bid reveal 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.json $ laconic registry auction bid reveal 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.json
``` ```
Set authority bond (after winning auction): Set authority bond (after winning auction):
```bash ```bash
$ laconic cns authority bond set laconic 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 $ laconic registry authority bond set laconic 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785
``` ```
Create sub-authority (same owner as parent authority): Create sub-authority (same owner as parent authority):
```bash ```bash
$ laconic cns authority reserve echo.laconic $ laconic registry authority reserve echo.laconic
``` ```
Create sub-authority (custom owner for sub-authority): Create sub-authority (custom owner for sub-authority):
```bash ```bash
$ laconic cns authority reserve kube.laconic --owner ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu $ laconic registry authority reserve kube.laconic --owner ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu
``` ```
Set name: Set name:
```bash ```bash
$ laconic cns name set crn://laconic/watcher/erc20 bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba $ laconic registry name set lrn://laconic/watcher/erc20 bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba
``` ```
Lookup name information: Lookup name information:
```bash ```bash
$ laconic cns name lookup crn://laconic/watcher/erc20 $ laconic registry name lookup lrn://laconic/watcher/erc20
[ [
{ {
"latest": { "latest": {
@ -344,7 +344,7 @@ $ laconic cns name lookup crn://laconic/watcher/erc20
Resolve name: Resolve name:
```bash ```bash
$ laconic cns name resolve crn://laconic/watcher/erc20 $ laconic registry name resolve lrn://laconic/watcher/erc20
[ [
{ {
"id": "bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba", "id": "bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba",
@ -385,9 +385,9 @@ $ laconic cns name resolve crn://laconic/watcher/erc20
Delete name: Delete name:
```bash ```bash
$ laconic cns name delete crn://laconic/watcher/erc20 $ laconic registry name delete lrn://laconic/watcher/erc20
$ laconic cns name resolve crn://laconic/watcher/erc20 $ laconic registry name resolve lrn://laconic/watcher/erc20
[ [
null null
] ]
@ -396,20 +396,20 @@ $ laconic cns name resolve crn://laconic/watcher/erc20
Create bond: Create bond:
```bash ```bash
$ laconic cns bond create --type aphoton --quantity 1000 $ laconic registry bond create --type photon --quantity 1000
``` ```
List bonds: List bonds:
```bash ```bash
$ laconic cns bond list $ laconic registry bond list
[ [
{ {
"id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785", "id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785",
"owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "aphoton", "type": "photon",
"quantity": "698000000" "quantity": "698000000"
} }
] ]
@ -419,7 +419,7 @@ $ laconic cns bond list
"owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "aphoton", "type": "photon",
"quantity": "1000" "quantity": "1000"
} }
] ]
@ -430,14 +430,14 @@ $ laconic cns bond list
Get bond: Get bond:
```bash ```bash
$ laconic cns bond get --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 $ laconic registry bond get --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785
[ [
{ {
"id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785", "id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785",
"owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "aphoton", "type": "photon",
"quantity": "691000000" "quantity": "691000000"
} }
] ]
@ -448,14 +448,14 @@ $ laconic cns bond get --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335
Query bonds by owner: Query bonds by owner:
```bash ```bash
$ laconic cns bond list --owner ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8 $ laconic registry bond list --owner ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8
[ [
{ {
"id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785", "id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785",
"owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "aphoton", "type": "photon",
"quantity": "684000000" "quantity": "684000000"
} }
] ]
@ -465,7 +465,7 @@ $ laconic cns bond list --owner ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8
"owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "aphoton", "type": "photon",
"quantity": "1000" "quantity": "1000"
} }
] ]
@ -476,41 +476,41 @@ $ laconic cns bond list --owner ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8
Refill bond: Refill bond:
```bash ```bash
$ laconic cns bond refill --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --type aphoton --quantity 1000 $ laconic registry bond refill --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --type photon --quantity 1000
``` ```
Withdraw funds from bond: Withdraw funds from bond:
```bash ```bash
$ laconic cns bond withdraw --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --type aphoton --quantity 500 $ laconic registry bond withdraw --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --type photon --quantity 500
``` ```
Cancel bond: Cancel bond:
```bash ```bash
$ laconic cns bond cancel --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 $ laconic registry bond cancel --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785
``` ```
Associate bond (with record): Associate bond (with record):
```bash ```bash
$ laconic cns bond associate --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba --bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0 $ laconic registry bond associate --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba --bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0
``` ```
Disassociate bond (from record): Disassociate bond (from record):
```bash ```bash
$ laconic cns bond dissociate --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba $ laconic registry bond dissociate --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba
``` ```
Dissociate all records from bond: Dissociate all records from bond:
```bash ```bash
$ laconic cns bond records dissociate --bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0 $ laconic registry bond records dissociate --bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0
``` ```
Reassociate records (switch bond): Reassociate records (switch bond):
```bash ```bash
$ laconic cns bond records reassociate --old-bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0 --new-bond-id 3e11c61f179897e4b12e9b63de35d36f88ac146755e7a28ce0bcdd07cf3a03ae $ laconic registry bond records reassociate --old-bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0 --new-bond-id 3e11c61f179897e4b12e9b63de35d36f88ac146755e7a28ce0bcdd07cf3a03ae
``` ```

2
config.example.yml
View File

@ -1,5 +1,5 @@
services: services:
cns: registry:
restEndpoint: 'http://localhost:1317' restEndpoint: 'http://localhost:1317'
gqlEndpoint: 'http://localhost:9473/api' gqlEndpoint: 'http://localhost:9473/api'
userKey: userKey:

2
package.json
View File

@ -1,6 +1,6 @@
{ {
"name": "@cerc-io/laconic-registry-cli", "name": "@cerc-io/laconic-registry-cli",
"version": "0.1.10", "version": "0.2.0",
"main": "index.js", "main": "index.js",
"repository": "git@github.com:cerc-io/laconic-registry-cli.git", "repository": "git@github.com:cerc-io/laconic-registry-cli.git",
"author": "", "author": "",

10
src/cmds/cns-cmds/account-cmds/get.ts → src/cmds/registry-cmds/account-cmds/get.ts
View File

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

0
src/cmds/cns-cmds/account.ts → src/cmds/registry-cmds/account.ts
View File

12
src/cmds/cns-cmds/auction-cmds/bid-cmds/commit.ts → src/cmds/registry-cmds/auction-cmds/bid-cmds/commit.ts
View File

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

12
src/cmds/cns-cmds/auction-cmds/bid-cmds/reveal.ts → src/cmds/registry-cmds/auction-cmds/bid-cmds/reveal.ts
View File

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

0
src/cmds/cns-cmds/auction-cmds/bid.ts → src/cmds/registry-cmds/auction-cmds/bid.ts
View File

10
src/cmds/cns-cmds/auction-cmds/get.ts → src/cmds/registry-cmds/auction-cmds/get.ts
View File

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

0
src/cmds/cns-cmds/auction.ts → src/cmds/registry-cmds/auction.ts
View File

12
src/cmds/cns-cmds/authority-cmds/bond-cmds/set.ts → src/cmds/registry-cmds/authority-cmds/bond-cmds/set.ts
View File

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

0
src/cmds/cns-cmds/authority-cmds/bond.ts → src/cmds/registry-cmds/authority-cmds/bond.ts
View File

12
src/cmds/cns-cmds/authority-cmds/reserve.ts → src/cmds/registry-cmds/authority-cmds/reserve.ts
View File

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

10
src/cmds/cns-cmds/authority-cmds/whois.ts → src/cmds/registry-cmds/authority-cmds/whois.ts
View File

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

0
src/cmds/cns-cmds/authority.ts → src/cmds/registry-cmds/authority.ts
View File

12
src/cmds/cns-cmds/bond-cmds/associate.ts → src/cmds/registry-cmds/bond-cmds/associate.ts
View File

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

12
src/cmds/cns-cmds/bond-cmds/cancel.ts → src/cmds/registry-cmds/bond-cmds/cancel.ts
View File

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

12
src/cmds/cns-cmds/bond-cmds/create.ts → src/cmds/registry-cmds/bond-cmds/create.ts
View File

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

12
src/cmds/cns-cmds/bond-cmds/dissociate.ts → src/cmds/registry-cmds/bond-cmds/dissociate.ts
View File

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

10
src/cmds/cns-cmds/bond-cmds/get.ts → src/cmds/registry-cmds/bond-cmds/get.ts
View File

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

10
src/cmds/cns-cmds/bond-cmds/list.ts → src/cmds/registry-cmds/bond-cmds/list.ts
View File

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

12
src/cmds/cns-cmds/bond-cmds/records-cmds/dissociate.ts → src/cmds/registry-cmds/bond-cmds/records-cmds/dissociate.ts
View File

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

12
src/cmds/cns-cmds/bond-cmds/records-cmds/reassociate.ts → src/cmds/registry-cmds/bond-cmds/records-cmds/reassociate.ts
View File

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

0
src/cmds/cns-cmds/bond-cmds/records.ts → src/cmds/registry-cmds/bond-cmds/records.ts
View File

12
src/cmds/cns-cmds/bond-cmds/refill.ts → src/cmds/registry-cmds/bond-cmds/refill.ts
View File

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

12
src/cmds/cns-cmds/bond-cmds/withdraw.ts → src/cmds/registry-cmds/bond-cmds/withdraw.ts
View File

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

0
src/cmds/cns-cmds/bond.ts → src/cmds/registry-cmds/bond.ts
View File

12
src/cmds/cns-cmds/name-cmds/delete.ts → src/cmds/registry-cmds/name-cmds/delete.ts
View File

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

10
src/cmds/cns-cmds/name-cmds/lookup.ts → src/cmds/registry-cmds/name-cmds/lookup.ts
View File

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

10
src/cmds/cns-cmds/name-cmds/resolve.ts → src/cmds/registry-cmds/name-cmds/resolve.ts
View File

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

12
src/cmds/cns-cmds/name-cmds/set.ts → src/cmds/registry-cmds/name-cmds/set.ts
View File

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

0
src/cmds/cns-cmds/name.ts → src/cmds/registry-cmds/name.ts
View File

10
src/cmds/cns-cmds/record-cmds/get.ts → src/cmds/registry-cmds/record-cmds/get.ts
View File

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

10
src/cmds/cns-cmds/record-cmds/list.ts → src/cmds/registry-cmds/record-cmds/list.ts
View File

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

12
src/cmds/cns-cmds/record-cmds/publish.ts → src/cmds/registry-cmds/record-cmds/publish.ts
View File

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

0
src/cmds/cns-cmds/record.ts → src/cmds/registry-cmds/record.ts
View File

12
src/cmds/cns-cmds/status.ts → src/cmds/registry-cmds/status.ts
View File

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

12
src/cmds/cns-cmds/tokens-cmds/send.ts → src/cmds/registry-cmds/tokens-cmds/send.ts
View File

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

0
src/cmds/cns-cmds/tokens.ts → src/cmds/registry-cmds/tokens.ts
View File

6
src/cmds/cns.ts → src/cmds/registry.ts
View File

@ -1,8 +1,8 @@
import yargs from 'yargs'; 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) => { exports.builder = (yargs: yargs.Argv) => {
return yargs return yargs
@ -17,7 +17,7 @@ exports.builder = (yargs: yargs.Argv) => {
gas: { type: 'string' }, gas: { type: 'string' },
fees: { type: 'string' } fees: { type: 'string' }
}) })
.commandDir('cns-cmds') .commandDir('registry-cmds')
.demandCommand() .demandCommand()
.help(); .help();
}; };

155
test/cli.test.ts
View File

@ -31,8 +31,8 @@ describe('Test laconic CLI commands', () => {
expect(errorOutput).toContain('laconic <command>'); expect(errorOutput).toContain('laconic <command>');
}); });
test('laconic cns', async () => { test('laconic registry', async () => {
const result = spawnSync('laconic', ['cns']); const result = spawnSync('laconic', ['registry']);
expect(result.status).toBe(1); expect(result.status).toBe(1);
const output = result.stdout.toString().trim(); const output = result.stdout.toString().trim();
@ -40,15 +40,15 @@ describe('Test laconic CLI commands', () => {
// Expect error with usage string // Expect error with usage string
expect(output).toBe(''); expect(output).toBe('');
expect(errorOutput).toContain('laconic cns'); expect(errorOutput).toContain('laconic registry');
expect(errorOutput).toContain('CNS tools'); expect(errorOutput).toContain('Registry tools');
expect(errorOutput).toContain('Commands:'); expect(errorOutput).toContain('Commands:');
}); });
// TODO: Break up tests into separate files // TODO: Break up tests into separate files
// TODO: Add tests for CNS commands with all available flags // TODO: Add tests for registry commands with all available flags
describe('laconic CNS commands', () => { describe('laconic registry commands', () => {
const testAccount = process.env.TEST_ACCOUNT; const testAccount = process.env.TEST_ACCOUNT;
assert(testAccount, 'TEST_ACCOUNT not set in env'); assert(testAccount, 'TEST_ACCOUNT not set in env');
const testAccount2 = 'laconic1pmuxrcnuhhf8qdllzuf2ctj2tnwwcg6yswqnyd'; const testAccount2 = 'laconic1pmuxrcnuhhf8qdllzuf2ctj2tnwwcg6yswqnyd';
@ -58,11 +58,11 @@ describe('Test laconic CLI commands', () => {
const testRecordFilePath = 'test/data/watcher-record.yml'; const testRecordFilePath = 'test/data/watcher-record.yml';
let testAuctionId: string, testRecordId: string, testRecordBondId: string; let testAuctionId: string, testRecordId: string, testRecordBondId: string;
test('laconic cns status', async () => { test('laconic registry status', async () => {
const result = spawnSync('laconic', ['cns', 'status']); const result = spawnSync('laconic', ['registry', 'status']);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expect output object to have CNS status props // Expect output object to have registry status props
expect(outputObj).toHaveProperty('version'); expect(outputObj).toHaveProperty('version');
expect(outputObj).toHaveProperty('node'); expect(outputObj).toHaveProperty('node');
expect(outputObj).toHaveProperty('node.network', CHAIN_ID); expect(outputObj).toHaveProperty('node.network', CHAIN_ID);
@ -80,8 +80,9 @@ describe('Test laconic CLI commands', () => {
let bondBalance = 1000000000; let bondBalance = 1000000000;
let bondId: string; let bondId: string;
test('laconic cns bond create --type <type> --quantity <quantity> --gas <gas> --fees <fees>', async () => { test('laconic registry bond create --type <type> --quantity <quantity> --gas <gas> --fees <fees>', async () => {
const result = spawnSync('laconic', ['cns', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondBalance.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]); const result = spawnSync('laconic', ['registry', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondBalance.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expect output object to have resultant bond id // Expect output object to have resultant bond id
@ -90,8 +91,8 @@ describe('Test laconic CLI commands', () => {
bondId = outputObj.bondId; bondId = outputObj.bondId;
}); });
test('laconic cns bond list', async () => { test('laconic registry bond list', async () => {
const result = spawnSync('laconic', ['cns', 'bond', 'list']); const result = spawnSync('laconic', ['registry', 'bond', 'list']);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected bond // Expected bond
@ -101,8 +102,8 @@ describe('Test laconic CLI commands', () => {
expect(outputObj[0]).toEqual(expectedBond); expect(outputObj[0]).toEqual(expectedBond);
}); });
test('laconic cns bond list --owner <owner_address>', async () => { test('laconic registry bond list --owner <owner_address>', async () => {
const result = spawnSync('laconic', ['cns', 'bond', 'list', '--owner', bondOwner]); const result = spawnSync('laconic', ['registry', 'bond', 'list', '--owner', bondOwner]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected bond // Expected bond
@ -112,8 +113,8 @@ describe('Test laconic CLI commands', () => {
expect(outputObj[0]).toEqual(expectedBond); expect(outputObj[0]).toEqual(expectedBond);
}); });
test('laconic cns bond get --id <bond_id>', async () => { test('laconic registry bond get --id <bond_id>', async () => {
const result = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]); const result = spawnSync('laconic', ['registry', 'bond', 'get', '--id', bondId]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected bond // Expected bond
@ -123,18 +124,18 @@ describe('Test laconic CLI commands', () => {
expect(outputObj[0]).toEqual(expectedBond); expect(outputObj[0]).toEqual(expectedBond);
}); });
test('laconic cns bond refill --id <bond_id> --type <type> --quantity <quantity>', async () => { test('laconic registry bond refill --id <bond_id> --type <type> --quantity <quantity>', async () => {
const bondRefillAmount = 1000; const bondRefillAmount = 1000;
bondBalance += bondRefillAmount; bondBalance += bondRefillAmount;
const result = spawnSync('laconic', ['cns', 'bond', 'refill', '--id', bondId, '--type', TOKEN_TYPE, '--quantity', bondRefillAmount.toString()]); const result = spawnSync('laconic', ['registry', 'bond', 'refill', '--id', bondId, '--type', TOKEN_TYPE, '--quantity', bondRefillAmount.toString()]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
// Check updated bond // Check updated bond
const bondResult = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]); const bondResult = spawnSync('laconic', ['registry', 'bond', 'get', '--id', bondId]);
const bondOutputObj = checkResultAndRetrieveOutput(bondResult); const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
// Expected bond // Expected bond
@ -144,18 +145,18 @@ describe('Test laconic CLI commands', () => {
expect(bondOutputObj[0]).toEqual(expectedBond); expect(bondOutputObj[0]).toEqual(expectedBond);
}); });
test('laconic cns bond withdraw --id <bond_id> --type <type> --quantity <quantity>', async () => { test('laconic registry bond withdraw --id <bond_id> --type <type> --quantity <quantity>', async () => {
const bondWithdrawAmount = 500; const bondWithdrawAmount = 500;
bondBalance -= bondWithdrawAmount; bondBalance -= bondWithdrawAmount;
const result = spawnSync('laconic', ['cns', 'bond', 'withdraw', '--id', bondId, '--type', TOKEN_TYPE, '--quantity', bondWithdrawAmount.toString()]); const result = spawnSync('laconic', ['registry', 'bond', 'withdraw', '--id', bondId, '--type', TOKEN_TYPE, '--quantity', bondWithdrawAmount.toString()]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
// Check updated bond // Check updated bond
const bondResult = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]); const bondResult = spawnSync('laconic', ['registry', 'bond', 'get', '--id', bondId]);
const bondOutputObj = checkResultAndRetrieveOutput(bondResult); const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
// Expected bond // Expected bond
@ -166,15 +167,15 @@ describe('Test laconic CLI commands', () => {
expect(bondOutputObj[0]).toEqual(expectedBond); expect(bondOutputObj[0]).toEqual(expectedBond);
}); });
test('laconic cns bond cancel --id <bond_id>', async () => { test('laconic registry bond cancel --id <bond_id>', async () => {
const result = spawnSync('laconic', ['cns', 'bond', 'cancel', '--id', bondId]); const result = spawnSync('laconic', ['registry', 'bond', 'cancel', '--id', bondId]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
// Check updated bond // Check updated bond
const bondResult = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]); const bondResult = spawnSync('laconic', ['registry', 'bond', 'get', '--id', bondId]);
const bondOutputObj = checkResultAndRetrieveOutput(bondResult); const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
// Expect empty object // Expect empty object
@ -186,8 +187,8 @@ describe('Test laconic CLI commands', () => {
describe('Account and tokens operations', () => { describe('Account and tokens operations', () => {
let balanceBeforeSend: number; let balanceBeforeSend: number;
test('laconic cns account get --address <account_address>', async () => { test('laconic registry account get --address <account_address>', async () => {
const result = spawnSync('laconic', ['cns', 'account', 'get', '--address', testAccount]); const result = spawnSync('laconic', ['registry', 'account', 'get', '--address', testAccount]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected account // Expected account
@ -203,11 +204,11 @@ describe('Test laconic CLI commands', () => {
expect(balanceBeforeSend).toBeLessThan(initialAccountBalance); expect(balanceBeforeSend).toBeLessThan(initialAccountBalance);
}); });
test('laconic cns tokens send --address <account_address> --type <token_type> --quantity <quantity>', async () => { test('laconic registry tokens send --address <account_address> --type <token_type> --quantity <quantity>', async () => {
const sendAmount = 1000000000; const sendAmount = 1000000000;
const balanceAfterSend = balanceBeforeSend - sendAmount; const balanceAfterSend = balanceBeforeSend - sendAmount;
const result = spawnSync('laconic', ['cns', 'tokens', 'send', '--address', testAccount2, '--type', TOKEN_TYPE, '--quantity', sendAmount.toString()]); const result = spawnSync('laconic', ['registry', 'tokens', 'send', '--address', testAccount2, '--type', TOKEN_TYPE, '--quantity', sendAmount.toString()]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected acconts // Expected acconts
@ -225,11 +226,10 @@ describe('Test laconic CLI commands', () => {
const gas = 250000; const gas = 250000;
const bondBalance = 1000000000; const bondBalance = 1000000000;
test('laconic cns record publish --filename <record_file> --bond-id <bond_id> --gas <gas>', async () => { test('laconic registry record publish --filename <record_file> --bond-id <bond_id> --gas <gas>', async () => {
// Create a new bond to be associated with the record // Create a new bond to be associated with the record
({ bondId: testRecordBondId } = createBond(bondBalance)); ({ bondId: testRecordBondId } = createBond(bondBalance));
const result = spawnSync('laconic', ['registry', 'record', 'publish', '--filename', testRecordFilePath, '--bond-id', testRecordBondId, '--gas', gas.toString()]);
const result = spawnSync('laconic', ['cns', 'record', 'publish', '--filename', testRecordFilePath, '--bond-id', testRecordBondId, '--gas', gas.toString()]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expect output object to resultant bond id // Expect output object to resultant bond id
@ -238,8 +238,8 @@ describe('Test laconic CLI commands', () => {
testRecordId = outputObj.id; testRecordId = outputObj.id;
}); });
test('laconic cns record list', async () => { test('laconic registry record list', async () => {
const result = spawnSync('laconic', ['cns', 'record', 'list']); const result = spawnSync('laconic', ['registry', 'record', 'list']);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected record // Expected record
@ -253,8 +253,8 @@ describe('Test laconic CLI commands', () => {
expect(outputObj[0].owners.length).toEqual(1); expect(outputObj[0].owners.length).toEqual(1);
}); });
test('laconic cns record get --id <record_id>', async () => { test('laconic registry record get --id <record_id>', async () => {
const result = spawnSync('laconic', ['cns', 'record', 'get', '--id', testRecordId]); const result = spawnSync('laconic', ['registry', 'record', 'get', '--id', testRecordId]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected record // Expected record
@ -267,14 +267,14 @@ describe('Test laconic CLI commands', () => {
describe('Bond records operations', () => { describe('Bond records operations', () => {
let testRecordBondId2: string; let testRecordBondId2: string;
test('laconic cns bond dissociate --id <record_id>', async () => { test('laconic registry bond dissociate --id <record_id>', async () => {
const result = spawnSync('laconic', ['cns', 'bond', 'dissociate', '--id', testRecordId]); const result = spawnSync('laconic', ['registry', 'bond', 'dissociate', '--id', testRecordId]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
const recordResult = spawnSync('laconic', ['cns', 'record', 'get', '--id', testRecordId]); const recordResult = spawnSync('laconic', ['registry', 'record', 'get', '--id', testRecordId]);
const recordOutputObj = checkResultAndRetrieveOutput(recordResult); const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
// Expected record // Expected record
@ -284,17 +284,17 @@ describe('Test laconic CLI commands', () => {
expect(recordOutputObj[0]).toMatchObject(expectedRecord); expect(recordOutputObj[0]).toMatchObject(expectedRecord);
}); });
test('laconic cns bond associate --id <record_id> --bond-id <bond_id>', async () => { test('laconic registry bond associate --id <record_id> --bond-id <bond_id>', async () => {
// Create a new bond to be associated with the record // Create a new bond to be associated with the record
({ bondId: testRecordBondId2 } = createBond(bondBalance)); ({ bondId: testRecordBondId2 } = createBond(bondBalance));
const result = spawnSync('laconic', ['cns', 'bond', 'associate', '--id', testRecordId, '--bond-id', testRecordBondId2]); const result = spawnSync('laconic', ['registry', 'bond', 'associate', '--id', testRecordId, '--bond-id', testRecordBondId2]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
const recordResult = spawnSync('laconic', ['cns', 'record', 'get', '--id', testRecordId]); const recordResult = spawnSync('laconic', ['registry', 'record', 'get', '--id', testRecordId]);
const recordOutputObj = checkResultAndRetrieveOutput(recordResult); const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
// Expected record // Expected record
@ -304,14 +304,14 @@ describe('Test laconic CLI commands', () => {
expect(recordOutputObj[0]).toMatchObject(expectedRecord); expect(recordOutputObj[0]).toMatchObject(expectedRecord);
}); });
test('laconic cns bond records reassociate --old-bond-id <old_bond_id> --new-bond-id <new_bond_id>', async () => { test('laconic registry bond records reassociate --old-bond-id <old_bond_id> --new-bond-id <new_bond_id>', async () => {
const result = spawnSync('laconic', ['cns', 'bond', 'records', 'reassociate', '--old-bond-id', testRecordBondId2, '--new-bond-id', testRecordBondId]); const result = spawnSync('laconic', ['registry', 'bond', 'records', 'reassociate', '--old-bond-id', testRecordBondId2, '--new-bond-id', testRecordBondId]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
const recordResult = spawnSync('laconic', ['cns', 'record', 'get', '--id', testRecordId]); const recordResult = spawnSync('laconic', ['registry', 'record', 'get', '--id', testRecordId]);
const recordOutputObj = checkResultAndRetrieveOutput(recordResult); const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
// Expected record // Expected record
@ -324,18 +324,17 @@ describe('Test laconic CLI commands', () => {
}); });
describe('Name authority operations (pre auction)', () => { describe('Name authority operations (pre auction)', () => {
test('laconic cns authority reserve <authority_name>', async () => { test('laconic registry authority reserve <authority_name>', async () => {
const result = spawnSync('laconic', ['cns', 'authority', 'reserve', testAuthorityName]); const result = spawnSync('laconic', ['registry', 'authority', 'reserve', testAuthorityName]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expect result // Expect result
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
}); });
test('laconic cns authority whois <authority_name>', async () => { test('laconic registry authority whois <authority_name>', async () => {
const result = spawnSync('laconic', ['cns', 'authority', 'whois', testAuthorityName]); const result = spawnSync('laconic', ['registry', 'authority', 'whois', testAuthorityName]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected authority (still in auction) // Expected authority (still in auction)
const expectedAuthority = getAuthorityObj({ owner: '', status: 'auction', auction: getAuctionObj({ owner: testAccount }) }); const expectedAuthority = getAuthorityObj({ owner: '', status: 'auction', auction: getAuctionObj({ owner: testAccount }) });
@ -352,8 +351,8 @@ describe('Test laconic CLI commands', () => {
const bidAmount = 25000000; const bidAmount = 25000000;
let bidRevealFilePath: string; let bidRevealFilePath: string;
test('laconic cns auction get <auction_id>', async () => { test('laconic registry auction get <auction_id>', async () => {
const result = spawnSync('laconic', ['cns', 'auction', 'get', testAuctionId]); const result = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected auction (still in commit stage) // Expected auction (still in commit stage)
@ -363,8 +362,8 @@ describe('Test laconic CLI commands', () => {
expect(outputObj[0]).toMatchObject(expectedAuction); expect(outputObj[0]).toMatchObject(expectedAuction);
}); });
test('laconic cns auction bid commit <auction_id> <quantity> <type>', async () => { test('laconic registry auction bid commit <auction_id> <quantity> <type>', async () => {
const result = spawnSync('laconic', ['cns', 'auction', 'bid', 'commit', testAuctionId, bidAmount.toString(), TOKEN_TYPE]); const result = spawnSync('laconic', ['registry', 'auction', 'bid', 'commit', testAuctionId, bidAmount.toString(), TOKEN_TYPE]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
@ -373,11 +372,11 @@ describe('Test laconic CLI commands', () => {
bidRevealFilePath = outputObj.reveal_file; bidRevealFilePath = outputObj.reveal_file;
}); });
test('laconic cns auction bid reveal <auction_id> <file_path>', async () => { test('laconic registry auction bid reveal <auction_id> <file_path>', async () => {
// Wait for auction commits duration (60s) // Wait for auction commits duration (60s)
await delay(AUCTION_COMMIT_DURATION * 1000); await delay(AUCTION_COMMIT_DURATION * 1000);
const auctionResult = spawnSync('laconic', ['cns', 'auction', 'get', testAuctionId]); const auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult); const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
const expectedAuction = getAuctionObj({ owner: testAccount, status: 'reveal' }); const expectedAuction = getAuctionObj({ owner: testAccount, status: 'reveal' });
@ -387,7 +386,7 @@ describe('Test laconic CLI commands', () => {
expect(auctionOutputObj[0].bids[0]).toMatchObject(expectedBid); expect(auctionOutputObj[0].bids[0]).toMatchObject(expectedBid);
// Reveal bid // Reveal bid
const result = spawnSync('laconic', ['cns', 'auction', 'bid', 'reveal', testAuctionId, bidRevealFilePath]); const result = spawnSync('laconic', ['registry', 'auction', 'bid', 'reveal', testAuctionId, bidRevealFilePath]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
@ -407,11 +406,11 @@ describe('Test laconic CLI commands', () => {
const testSubAuthorityName = 'echo.laconic'; const testSubAuthorityName = 'echo.laconic';
const testSubAuthorityName2 = 'kube.laconic'; const testSubAuthorityName2 = 'kube.laconic';
test('laconic cns authority whois <authority_name>', async () => { test('laconic registry authority whois <authority_name>', async () => {
// Wait for auction reveals duration (60s) // Wait for auction reveals duration (60s)
await delay(AUCTION_REVEAL_DURATION * 1000); await delay(AUCTION_REVEAL_DURATION * 1000);
const result = spawnSync('laconic', ['cns', 'authority', 'whois', testAuthorityName]); const result = spawnSync('laconic', ['registry', 'authority', 'whois', testAuthorityName]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected authority (active) // Expected authority (active)
@ -421,19 +420,19 @@ describe('Test laconic CLI commands', () => {
expect(outputObj[0]).toMatchObject(expectedAuthority); expect(outputObj[0]).toMatchObject(expectedAuthority);
}, (AUCTION_REVEAL_DURATION + 5) * 1000); }, (AUCTION_REVEAL_DURATION + 5) * 1000);
test('laconic cns authority bond set laconic <bond_id>', async () => { test('laconic registry authority bond set laconic <bond_id>', async () => {
// Create a new bond to be set on the authority // Create a new bond to be set on the authority
const bondBalance = 1000000000; const bondBalance = 1000000000;
const { bondId } = createBond(bondBalance); const { bondId } = createBond(bondBalance);
const result = spawnSync('laconic', ['cns', 'authority', 'bond', 'set', testAuthorityName, bondId]); const result = spawnSync('laconic', ['registry', 'authority', 'bond', 'set', testAuthorityName, bondId]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
// Check updated authority // Check updated authority
const authorityResult = spawnSync('laconic', ['cns', 'authority', 'whois', testAuthorityName]); const authorityResult = spawnSync('laconic', ['registry', 'authority', 'whois', testAuthorityName]);
const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult); const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
// Expected authority (active with bond) // Expected authority (active with bond)
@ -443,15 +442,15 @@ describe('Test laconic CLI commands', () => {
expect(authorityOutputObj[0]).toMatchObject(expectedAuthority); expect(authorityOutputObj[0]).toMatchObject(expectedAuthority);
}); });
test('laconic cns authority reserve <sub_authority> (same owner)', async () => { test('laconic registry authority reserve <sub_authority> (same owner)', async () => {
const result = spawnSync('laconic', ['cns', 'authority', 'reserve', testSubAuthorityName]); const result = spawnSync('laconic', ['registry', 'authority', 'reserve', testSubAuthorityName]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
// Check updated authority // Check updated authority
const authorityResult = spawnSync('laconic', ['cns', 'authority', 'whois', testSubAuthorityName]); const authorityResult = spawnSync('laconic', ['registry', 'authority', 'whois', testSubAuthorityName]);
const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult); const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
// Expected authority (active with bond) // Expected authority (active with bond)
@ -461,15 +460,15 @@ describe('Test laconic CLI commands', () => {
expect(authorityOutputObj[0]).toMatchObject(expectedAuthority); expect(authorityOutputObj[0]).toMatchObject(expectedAuthority);
}); });
test('laconic cns authority reserve <sub_authority> --owner <owner_address> (different owner)', async () => { test('laconic registry authority reserve <sub_authority> --owner <owner_address> (different owner)', async () => {
const result = spawnSync('laconic', ['cns', 'authority', 'reserve', testSubAuthorityName2, '--owner', testAccount2]); const result = spawnSync('laconic', ['registry', 'authority', 'reserve', testSubAuthorityName2, '--owner', testAccount2]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
// Check updated authority // Check updated authority
const authorityResult = spawnSync('laconic', ['cns', 'authority', 'whois', testSubAuthorityName2]); const authorityResult = spawnSync('laconic', ['registry', 'authority', 'whois', testSubAuthorityName2]);
const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult); const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
// Expected authority (active with bond) // Expected authority (active with bond)
@ -483,16 +482,16 @@ describe('Test laconic CLI commands', () => {
describe('Name operations', () => { describe('Name operations', () => {
const testName = 'lrn://laconic/watcher/erc20'; const testName = 'lrn://laconic/watcher/erc20';
test('laconic cns name set <name> <record_id>', async () => { test('laconic registry name set <name> <record_id>', async () => {
const result = spawnSync('laconic', ['cns', 'name', 'set', testName, testRecordId]); const result = spawnSync('laconic', ['registry', 'name', 'set', testName, testRecordId]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
}); });
test('laconic cns name lookup <name>', async () => { test('laconic registry name lookup <name>', async () => {
const result = spawnSync('laconic', ['cns', 'name', 'lookup', testName]); const result = spawnSync('laconic', ['registry', 'name', 'lookup', testName]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
@ -500,8 +499,8 @@ describe('Test laconic CLI commands', () => {
expect(outputObj[0]).toMatchObject({ latest: { id: testRecordId } }); expect(outputObj[0]).toMatchObject({ latest: { id: testRecordId } });
}); });
test('laconic cns name resolve <name>', async () => { test('laconic registry name resolve <name>', async () => {
const result = spawnSync('laconic', ['cns', 'name', 'resolve', testName]); const result = spawnSync('laconic', ['registry', 'name', 'resolve', testName]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected resolved record // Expected resolved record
@ -511,15 +510,15 @@ describe('Test laconic CLI commands', () => {
expect(outputObj[0]).toMatchObject(expectedRecord); expect(outputObj[0]).toMatchObject(expectedRecord);
}); });
test('laconic cns name delete <name>', async () => { test('laconic registry name delete <name>', async () => {
const result = spawnSync('laconic', ['cns', 'name', 'delete', testName]); const result = spawnSync('laconic', ['registry', 'name', 'delete', testName]);
const outputObj = checkResultAndRetrieveOutput(result); const outputObj = checkResultAndRetrieveOutput(result);
// Expected output // Expected output
expect(outputObj).toEqual({ success: true }); expect(outputObj).toEqual({ success: true });
// Check that name doesn't resolve // Check that name doesn't resolve
const resolveResult = spawnSync('laconic', ['cns', 'name', 'resolve', testName]); const resolveResult = spawnSync('laconic', ['registry', 'name', 'resolve', testName]);
const resolveOutputObj = checkResultAndRetrieveOutput(resolveResult); const resolveOutputObj = checkResultAndRetrieveOutput(resolveResult);
expect(resolveOutputObj.length).toEqual(0); expect(resolveOutputObj.length).toEqual(0);
}); });

2
test/helpers.ts
View File

@ -25,7 +25,7 @@ export function checkResultAndRetrieveOutput (result: SpawnSyncReturns<Buffer>):
} }
export function createBond (quantity: number): { bondId: string } { export function createBond (quantity: number): { bondId: string } {
const result = spawnSync('laconic', ['cns', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', quantity.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]); const result = spawnSync('laconic', ['registry', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', quantity.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]);
const output = result.stdout.toString().trim(); const output = result.stdout.toString().trim();
return JSON.parse(output); return JSON.parse(output);

2
test/run-tests.sh
View File

@ -15,7 +15,7 @@ laconic2d_gql_endpoint=http://127.0.0.1:9473/api
config_file="config.yml" config_file="config.yml"
config=$(cat <<EOL config=$(cat <<EOL
services: services:
cns: registry:
restEndpoint: $laconic2d_rpc_endpoint restEndpoint: $laconic2d_rpc_endpoint
gqlEndpoint: $laconic2d_gql_endpoint gqlEndpoint: $laconic2d_gql_endpoint
userKey: $laconic2d_key userKey: $laconic2d_key