Compare commits

..

No commits in common. "pm-repo-records-script" and "main" have entirely different histories.

88 changed files with 923 additions and 6224 deletions

View File

@ -1 +0,0 @@
TEST_ACCOUNT=

View File

@ -1,5 +0,0 @@
# Don't lint node_modules.
node_modules
# Don't lint build output.
dist

View File

@ -1,21 +0,0 @@
{
"env": {
"node": true
},
"extends": [
"semistandard",
"plugin:@typescript-eslint/recommended"
],
"parser": "@typescript-eslint/parser",
"parserOptions": {
"ecmaVersion": 12,
"sourceType": "module"
},
"plugins": [
"@typescript-eslint"
],
"rules": {
"indent": ["error", 2, { "SwitchCase": 1 }],
"@typescript-eslint/no-explicit-any": "off"
}
}

View File

@ -1,28 +0,0 @@
name: Lint
on:
pull_request:
branches:
- '*'
push:
branches:
- main
jobs:
lint:
runs-on: ubuntu-latest
strategy:
matrix:
node-version: [18.x]
steps:
- uses: actions/checkout@v3
- name: Download yarn
run: |
curl -fsSL -o /usr/local/bin/yarn https://github.com/yarnpkg/yarn/releases/download/v1.22.21/yarn-1.22.21.js
chmod +x /usr/local/bin/yarn
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node-version }}
- run: yarn
- name: Linter check
run: yarn lint

View File

@ -12,47 +12,34 @@ env:
DOCKER_HOST: unix:///var/run/dind.sock DOCKER_HOST: unix:///var/run/dind.sock
jobs: jobs:
cli_tests: sdk_tests:
runs-on: ubuntu-latest runs-on: ubuntu-latest
strategy:
matrix:
node-version: [18.x]
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v3
- name: Download yarn
run: |
curl -fsSL -o /usr/local/bin/yarn https://github.com/yarnpkg/yarn/releases/download/v1.22.21/yarn-1.22.21.js
chmod +x /usr/local/bin/yarn
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node-version }}
- name: Set registry
run: npm config set @cerc-io:registry https://git.vdb.to/api/packages/cerc-io/npm/
- name: Install dependencies and build
run: yarn && yarn build
- name: Install registry-cli
run: yarn global add file:$PWD
- name: Checkout laconicd - name: Checkout laconicd
uses: actions/checkout@v3 uses: actions/checkout@v3
with: with:
path: "./laconicd/" path: "./laconicd/"
repository: cerc-io/laconic2d # TODO: Update to laconicd after renaming repo repository: cerc-io/laconicd
fetch-depth: 0 fetch-depth: 0
ref: main ref: main
- name: Environment
- name: Build laconicd container run: ls -tlh && env
working-directory: ./laconicd/tests/sdk_tests - name: Start dockerd
run: |
dockerd -H $DOCKER_HOST --userland-proxy=false &
sleep 5
- name: build registry-cli container
run: docker build -t cerc/laconic-registry-cli:local-test --build-arg CERC_NPM_URL=https://git.vdb.to/api/packages/cerc-io/npm/ --build-arg CERC_NPM_AUTH_TOKEN="${{ secrets.CICD_PUBLISH_TOKEN }}" .
- name: build containers scripts
working-directory: laconicd/tests/sdk_tests
run: ./build-laconicd-container.sh run: ./build-laconicd-container.sh
- name: Start laconicd container - name: start laconicd container
env: working-directory: laconicd/tests/sdk_tests
TEST_AUCTION_ENABLED: true
run: docker compose up laconicd -d run: docker compose up laconicd -d
- name: Run registry-cli tests - name: Run registry-cli demo commands in registry-cli container
run: ./test/run-tests.sh run : ls -tla
- name: stop containers
- name: Stop containers working-directory: laconicd/tests/sdk_tests
run: docker compose down run: docker compose down

1
.gitignore vendored
View File

@ -4,7 +4,6 @@ dist/*
out out
config.yml config.yml
.env
*~ *~
.idea .idea

View File

@ -1 +0,0 @@
yarn lint

1
.npmrc
View File

@ -1 +0,0 @@
@cerc-io:registry=https://git.vdb.to/api/packages/cerc-io/npm/

150
README.md
View File

@ -1,43 +1,13 @@
# laconic-registry-client # laconic-cns-client
CLI utility written in TS, used to interact with laconicd. Depends on [registry-sdk](https://git.vdb.to/cerc-io/registry-sdk). CLI utility written in TS, used to interact with laconicd. Depends on [laconic-sdk](https://github.com/cerc-io/laconic-sdk).
## Install
- Add `.npmrc` file in desired project to resolve package
```bash
@cerc-io:registry=https://git.vdb.to/api/packages/cerc-io/npm/
```
This will set the registry for `cerc-io` scoped packages in the project
- Install the CLI using package manager
```bash
yarn add @cerc-io/laconic-registry-cli
```
- For installing CLI globally add `.npmrc` file above in home directory and run
```bash
yarn global add @cerc-io/laconic-registry-cli
```
## Setup ## Setup
* Run `yarn` to install all dependencies. * Run `yarn` to install all dependencies.
* Run `yarn build`.
* Create a `config.yml` file from [config.example.yml](./config.example.yml) file. * Create a `config.yml` file from [config.example.yml](./config.example.yml) file.
* Add CLI cmd to path
```bash
export PATH="$PWD/bin:$PATH"
```
## Account Setup ## Account Setup
Run the chain: Run the chain:
@ -45,13 +15,13 @@ Run the chain:
- In laconicd repo run: - In laconicd repo run:
```bash ```bash
TEST_AUCTION_ENABLED=true ./scripts/init.sh clean TEST_AUCTION_ENABLED=true ./init.sh
``` ```
Registering records in registry requires an account. To get account private key run: Registering records in CNS requires an account. To get account private key run:
```bash ```bash
laconicd keys export alice --keyring-backend test --unarmored-hex --unsafe $ laconicd keys export mykey --unarmored-hex --unsafe
``` ```
In `config.yml` file assign the account private key to `userKey`. In `config.yml` file assign the account private key to `userKey`.
@ -68,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 registry bond create --type photon --quantity 1000000000 --gas 200000 --fees 200000photon $ laconic cns bond create --type aphoton --quantity 1000000000 --gas 200000 --fees 200000aphoton
``` ```
## Operations ## Operations
@ -78,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 registry status $ laconic cns status
{ {
"version": "0.3.0", "version": "0.3.0",
"node": { "node": {
@ -112,16 +82,16 @@ $ laconic registry status
Get account details: Get account details:
```bash ```bash
$ laconic registry account get --address laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k $ laconic cns account get --address ethm133y09mveksh76uc99h4rl38nd033tk4e3y2z52
[ [
{ {
"address": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "address": "ethm133y09mveksh76uc99h4rl38nd033tk4e3y2z52",
"pubKey": "A2BeFMnq4h0v5/hP+trvQbCtVWwGGYNSHWRJ7Ae60biS", "pubKey": "A2BeFMnq4h0v5/hP+trvQbCtVWwGGYNSHWRJ7Ae60biS",
"number": "0", "number": "0",
"sequence": "37", "sequence": "37",
"balance": [ "balance": [
{ {
"type": "photon", "type": "aphoton",
"quantity": "89998999999999991999799300" "quantity": "89998999999999991999799300"
} }
] ]
@ -132,28 +102,28 @@ $ laconic registry account get --address laconic15za32wly5exgcrt2zfr8php4ya49n5y
Send tokens: Send tokens:
```bash ```bash
$ laconic registry tokens send --address laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k --type photon --quantity 1000000000 $ laconic cns tokens send --address ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu --type aphoton --quantity 1000000000
[ [
{ {
"address": "laconic1pmuxrcnuhhf8qdllzuf2ctj2tnwwcg6yswqnyd", "address": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"pubKey": "A68/q7/xazFzNj+rrvE07ALxkMgqw1ugL35VECkWAYvt", "pubKey": "A68/q7/xazFzNj+rrvE07ALxkMgqw1ugL35VECkWAYvt",
"number": "0", "number": "0",
"sequence": "16", "sequence": "16",
"balance": [ "balance": [
{ {
"type": "photon", "type": "aphoton",
"quantity": "99998999999999997973999700" "quantity": "99998999999999997973999700"
} }
] ]
}, },
{ {
"address": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "address": "ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu",
"pubKey": null, "pubKey": null,
"number": "12", "number": "12",
"sequence": "0", "sequence": "0",
"balance": [ "balance": [
{ {
"type": "photon", "type": "aphoton",
"quantity": "1000000000" "quantity": "1000000000"
} }
] ]
@ -177,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 registry record publish --filename watcher.yml --bond-id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --gas 250000 $ laconic cns record publish --filename watcher.yml --bond-id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --gas 250000
{ id: 'bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba' } { id: 'bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba' }
``` ```
@ -185,7 +155,7 @@ $ laconic registry record publish --filename watcher.yml --bond-id 58508984500aa
Get record: Get record:
```bash ```bash
$ laconic registry record get --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba $ laconic cns record get --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba
[ [
{ {
"id": "bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba", "id": "bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba",
@ -226,19 +196,19 @@ $ laconic registry record get --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf
List records: List records:
```bash ```bash
$ laconic registry record list $ laconic cns record list
``` ```
Reserve authority: Reserve authority:
```bash ```bash
$ laconic registry authority reserve laconic $ laconic cns authority reserve laconic
``` ```
Check authority information: Check authority information:
```bash ```bash
$ laconic registry authority whois laconic $ laconic cns authority whois laconic
[ [
{ {
"ownerAddress": "", "ownerAddress": "",
@ -250,20 +220,20 @@ $ laconic registry authority whois laconic
"auction": { "auction": {
"id": "0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48", "id": "0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48",
"status": "commit", "status": "commit",
"ownerAddress": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "ownerAddress": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"createTime": "2022-04-26T11:43:45.679728594", "createTime": "2022-04-26T11:43:45.679728594",
"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": "photon", "type": "aphoton",
"quantity": "1000000" "quantity": "1000000"
}, },
"revealFee": { "revealFee": {
"type": "photon", "type": "aphoton",
"quantity": "1000000" "quantity": "1000000"
}, },
"minimumBid": { "minimumBid": {
"type": "photon", "type": "aphoton",
"quantity": "5000000" "quantity": "5000000"
}, },
"winnerAddress": "", "winnerAddress": "",
@ -284,25 +254,25 @@ $ laconic registry authority whois laconic
Get authority auction info: Get authority auction info:
```bash ```bash
$ laconic registry auction get 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 $ laconic cns auction get 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48
[ [
{ {
"id": "0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48", "id": "0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48",
"status": "commit", "status": "commit",
"ownerAddress": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "ownerAddress": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"createTime": "2022-04-26T11:42:05.256059269", "createTime": "2022-04-26T11:42:05.256059269",
"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": "photon", "type": "aphoton",
"quantity": "1000000" "quantity": "1000000"
}, },
"revealFee": { "revealFee": {
"type": "photon", "type": "aphoton",
"quantity": "1000000" "quantity": "1000000"
}, },
"minimumBid": { "minimumBid": {
"type": "photon", "type": "aphoton",
"quantity": "5000000" "quantity": "5000000"
}, },
"winnerAddress": "", "winnerAddress": "",
@ -322,7 +292,7 @@ $ laconic registry auction get 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2
Commit an auction bid: Commit an auction bid:
```bash ```bash
$ laconic registry auction bid commit 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 25000000 photon $ laconic cns auction bid commit 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 25000000 aphoton
Reveal file: ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.json Reveal file: ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.json
``` ```
@ -330,37 +300,37 @@ Reveal file: ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.j
Reveal an auction bid: Reveal an auction bid:
```bash ```bash
$ laconic registry auction bid reveal 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.json $ laconic cns auction bid reveal 0294fb2e3659c347b53a6faf4bef041fd934f0f3ab13df6d2468d5d63abacd48 ./out/bafyreiay2rccax64yn4ljhvzvm3jkbebvzheyucuma5jlbpzpzd5i5gjuy.json
``` ```
Set authority bond (after winning auction): Set authority bond (after winning auction):
```bash ```bash
$ laconic registry authority bond set laconic 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 $ laconic cns authority bond set laconic 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785
``` ```
Create sub-authority (same owner as parent authority): Create sub-authority (same owner as parent authority):
```bash ```bash
$ laconic registry authority reserve echo.laconic $ laconic cns authority reserve echo.laconic
``` ```
Create sub-authority (custom owner for sub-authority): Create sub-authority (custom owner for sub-authority):
```bash ```bash
$ laconic registry authority reserve kube.laconic --owner laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k $ laconic cns authority reserve kube.laconic --owner ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu
``` ```
Set name: Set name:
```bash ```bash
$ laconic registry name set lrn://laconic/watcher/erc20 bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba $ laconic cns name set crn://laconic/watcher/erc20 bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba
``` ```
Lookup name information: Lookup name information:
```bash ```bash
$ laconic registry name lookup lrn://laconic/watcher/erc20 $ laconic cns name lookup crn://laconic/watcher/erc20
[ [
{ {
"latest": { "latest": {
@ -374,7 +344,7 @@ $ laconic registry name lookup lrn://laconic/watcher/erc20
Resolve name: Resolve name:
```bash ```bash
$ laconic registry name resolve lrn://laconic/watcher/erc20 $ laconic cns name resolve crn://laconic/watcher/erc20
[ [
{ {
"id": "bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba", "id": "bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba",
@ -415,9 +385,9 @@ $ laconic registry name resolve lrn://laconic/watcher/erc20
Delete name: Delete name:
```bash ```bash
$ laconic registry name delete lrn://laconic/watcher/erc20 $ laconic cns name delete crn://laconic/watcher/erc20
$ laconic registry name resolve lrn://laconic/watcher/erc20 $ laconic cns name resolve crn://laconic/watcher/erc20
[ [
null null
] ]
@ -426,30 +396,30 @@ $ laconic registry name resolve lrn://laconic/watcher/erc20
Create bond: Create bond:
```bash ```bash
$ laconic registry bond create --type photon --quantity 1000 $ laconic cns bond create --type aphoton --quantity 1000
``` ```
List bonds: List bonds:
```bash ```bash
$ laconic registry bond list $ laconic cns bond list
[ [
{ {
"id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785", "id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785",
"owner": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "photon", "type": "aphoton",
"quantity": "698000000" "quantity": "698000000"
} }
] ]
}, },
{ {
"id": "5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0", "id": "5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0",
"owner": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "photon", "type": "aphoton",
"quantity": "1000" "quantity": "1000"
} }
] ]
@ -460,14 +430,14 @@ $ laconic registry bond list
Get bond: Get bond:
```bash ```bash
$ laconic registry bond get --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 $ laconic cns bond get --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785
[ [
{ {
"id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785", "id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785",
"owner": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "photon", "type": "aphoton",
"quantity": "691000000" "quantity": "691000000"
} }
] ]
@ -478,24 +448,24 @@ $ laconic registry bond get --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa1953
Query bonds by owner: Query bonds by owner:
```bash ```bash
$ laconic registry bond list --owner laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k $ laconic cns bond list --owner ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8
[ [
{ {
"id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785", "id": "58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785",
"owner": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "photon", "type": "aphoton",
"quantity": "684000000" "quantity": "684000000"
} }
] ]
}, },
{ {
"id": "5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0", "id": "5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0",
"owner": "laconic15za32wly5exgcrt2zfr8php4ya49n5y7masu7k", "owner": "ethm1lfekr7gvqtnhpp2kwdc6u2n569cqsp4ww0m4y8",
"balance": [ "balance": [
{ {
"type": "photon", "type": "aphoton",
"quantity": "1000" "quantity": "1000"
} }
] ]
@ -506,41 +476,41 @@ $ laconic registry bond list --owner laconic15za32wly5exgcrt2zfr8php4ya49n5y7mas
Refill bond: Refill bond:
```bash ```bash
$ laconic registry bond refill --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --type photon --quantity 1000 $ laconic cns bond refill --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --type aphoton --quantity 1000
``` ```
Withdraw funds from bond: Withdraw funds from bond:
```bash ```bash
$ laconic registry bond withdraw --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --type photon --quantity 500 $ laconic cns bond withdraw --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 --type aphoton --quantity 500
``` ```
Cancel bond: Cancel bond:
```bash ```bash
$ laconic registry bond cancel --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785 $ laconic cns bond cancel --id 58508984500aa2ed18e059fa8203b40fbc9828e3bfa195361335c4e4524c4785
``` ```
Associate bond (with record): Associate bond (with record):
```bash ```bash
$ laconic registry bond associate --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba --bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0 $ laconic cns bond associate --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba --bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0
``` ```
Disassociate bond (from record): Disassociate bond (from record):
```bash ```bash
$ laconic registry bond dissociate --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba $ laconic cns bond dissociate --id bafyreic3auqajvgszh3vfjsouew2rsctswukc346dmlf273ln4g6iyyhba
``` ```
Dissociate all records from bond: Dissociate all records from bond:
```bash ```bash
$ laconic registry bond records dissociate --bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0 $ laconic cns bond records dissociate --bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0
``` ```
Reassociate records (switch bond): Reassociate records (switch bond):
```bash ```bash
$ laconic registry bond records reassociate --old-bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0 --new-bond-id 3e11c61f179897e4b12e9b63de35d36f88ac146755e7a28ce0bcdd07cf3a03ae $ laconic cns bond records reassociate --old-bond-id 5c40abd336ae1561f2a1b55be73b12f5a083080bf879b4c9288d182d238badb0 --new-bond-id 3e11c61f179897e4b12e9b63de35d36f88ac146755e7a28ce0bcdd07cf3a03ae
``` ```

View File

@ -1,9 +1,7 @@
services: services:
registry: cns:
rpcEndpoint: 'http://localhost:26657' restEndpoint: 'http://localhost:1317'
gqlEndpoint: 'http://localhost:9473/api' gqlEndpoint: 'http://localhost:9473/api'
userKey: userKey:
bondId: bondId:
chainId: laconic_9000-1 chainId: laconic_9000-1
gas: 200000
fees: 200000photon

View File

@ -1,119 +0,0 @@
# Registry Demo
## Setup
* Install laconic CLI globally:
```bash
# In laconic-registry-cli repo root
yarn && yarn build
yarn global add file:$PWD
```
* Run the laconicd chain:
```bash
# In laconci2d repo
make install
./scripts/init.sh clean
```
* Create and populate `config.yml` following [config.example.yml](./config.example.yml):
```bash
# In laconic-registry-cli repo root
cp config.example.yml config.yml
# Update the gas value in config.yml
# gas: 500000
# Get user private key
laconicd keys export alice --unarmored-hex --unsafe --keyring-backend test --home ~/.laconicd
# Set the output as 'userKey' in config.yml
# userKey: <ALICE_PRIVATE_KEY>
# Create a bond
laconic --config config.yml registry bond create --type photon --quantity 100000000000
# Get the bond id
laconic --config config.yml registry bond list | jq -r '.[].id'
# Set the output as 'bondId' in config.yml
# bondId: <BOND_ID>
```
## Run
* Publish records:
```bash
# Publishes records and corresponding 'deployment' records from given directory
# In laconic-registry-cli repo root
# Use records dir path for '--records' as required
yarn ts-node demo/scripts/publish-records.ts --config config.yml --records <RECORDS_DIR>
```
### Example
* Query for `ajna-watcher` deployment(s):
* Find the `WatcherRecord` for `ajna-watcher`:
```bash
WATCHER_RECORD_ID=$(laconic registry record list --all --type WatcherRecord --name ajna-watcher | jq -r '.[].id')
```
* Find corresponding deployment(s):
```bash
laconic registry record list --all --type WatcherDeploymentRecord watcher $WATCHER_RECORD_ID
# Get the deployment URL(s)
laconic registry record list --all --type WatcherDeploymentRecord watcher $WATCHER_RECORD_ID | jq -r '.[].attributes.url'
# Expected output:
https://ajna-watcher-endpoint.example.com
```
* Query for `sushiswap-v3-subgraph` deployment(s):
* Find the `SubgraphRecord` for `sushiswap-v3-subgraph`:
```bash
SUBGRAPH_RECORD_ID=$(laconic registry record list --all --type SubgraphRecord --name sushiswap-v3-subgraph | jq -r '.[].id')
```
* Find corresponding deployment(s):
```bash
laconic registry record list --all --type SubgraphDeploymentRecord subgraph $SUBGRAPH_RECORD_ID
# Get the deployment URL(s)
laconic registry record list --all --type SubgraphDeploymentRecord subgraph $SUBGRAPH_RECORD_ID | jq -r '.[].attributes.url'
# Expected output:
# https://sushiswap-v3-subgraph-endpoint.example.com
```
* Query for `geth` service deployment(s):
* Find the `ServiceRecord` for `geth`:
```bash
SERVICE_RECORD_ID=$(laconic registry record list --all --type ServiceRecord --name geth | jq -r '.[].id')
```
* Find corresponding deployment(s):
```bash
laconic registry record list --all --type ServiceDeploymentRecord service $SERVICE_RECORD_ID
# Get the deployment URL(s)
laconic registry record list --all --type ServiceDeploymentRecord service $SERVICE_RECORD_ID | jq -r '.[].attributes.url'
# Expected output:
# https://geth-rpc-endpoint-1.example.com
# https://geth-rpc-endpoint-2.example.com
```

View File

@ -1,276 +0,0 @@
import { config } from 'dotenv';
import yargs from 'yargs';
import path from 'path';
import fs from 'fs';
import assert from 'assert';
import { hideBin } from 'yargs/helpers';
import axios from 'axios';
import { Octokit } from '@octokit/rest';
// Load environment variables from .env file
config();
const GITEA_BASE_URL = 'https://git.vdb.to';
interface RepoRecord {
type: string
version: string
schema: string
name: string
url: string
clone_url: string
owner: {
name: string
type: 'Organization' | 'User'
url: string
}
is_private: boolean
is_archived: boolean
default_branch: string
latest_tag: {
tag_name: string
url: string
} | null
is_fork: boolean
fork_source: {
name: string
url: string
} | null
license: {
name: string
spdx_id: string
} | null
}
async function main () {
const argv = getArgs();
let repoRecord: RepoRecord;
if (argv.repoUrl.includes('github.com')) {
repoRecord = await createRepoRecord(argv.repoUrl);
} else {
repoRecord = await createGiteaRepoRecord(argv.repoUrl);
}
const jsonData = JSON.stringify(repoRecord, null, 2);
const recordsDir = path.resolve(argv.recordsDir);
const recordFile = `${recordsDir}/${repoRecord.name}.json`;
fs.writeFileSync(recordFile, jsonData, 'utf8');
console.log(`Repo record written to ${recordFile}`);
}
async function createRepoRecord (repoUrl: string): Promise<RepoRecord> {
const githubPAT = process.env.GITHUB_TOKEN;
assert(githubPAT, 'GITHUB_TOKEN not provided');
const octokit = new Octokit({
auth: githubPAT
});
const { owner, repo } = extractOwnerAndRepo(repoUrl);
// fetch repo details
const data = await getRepoDetails(octokit, owner, repo);
const repoRecord: RepoRecord = {
type: 'RepositoryRecord',
version: '0.1.0', // fetch from registry and increment if exists
schema: '',
name: data.name,
url: data.html_url,
clone_url: data.clone_url,
owner: {
name: data.owner.login,
type: data.owner.type,
url: data.owner.html_url
},
is_private: data.private,
is_archived: data.archived,
default_branch: data.default_branch,
latest_tag: null,
is_fork: data.fork,
fork_source: null,
license: null
};
// populate fork source
if (data.fork) {
repoRecord.fork_source = {
name: data.source.name,
url: data.source.html_url
};
}
// populate license
if (data.license) {
repoRecord.license = {
name: data.license.name,
spdx_id: data.license.spdx_id
};
}
// fetch and populate latest_tag
const latestTag = await getRepoLatestTag(octokit, owner, repo);
if (latestTag) {
repoRecord.latest_tag = {
tag_name: latestTag.tag_name,
url: latestTag.html_url
};
}
return repoRecord;
}
async function createGiteaRepoRecord (repoUrl: string): Promise<RepoRecord> {
const giteaPAT = process.env.GITEA_TOKEN;
assert(giteaPAT, 'GITEA_TOKEN not provided');
const { owner, repo } = extractOwnerAndRepo(repoUrl);
// fetch repo details
const data = await getGiteaRepoDetails(giteaPAT, owner, repo);
const repoRecord: RepoRecord = {
type: 'RepositoryRecord',
version: '0.1.0', // fetch from registry and increment if exists
schema: '',
name: data.name,
url: data.html_url,
clone_url: data.clone_url,
owner: {
name: data.owner.login,
// type: data.owner.type,
type: 'Organization',
url: data.owner.html_url
},
is_private: data.private,
is_archived: data.archived,
default_branch: data.default_branch,
latest_tag: null,
is_fork: data.fork,
fork_source: null,
license: null
};
// populate fork source
if (data.fork) {
repoRecord.fork_source = {
name: data.parent.name,
url: data.parent.html_url
};
}
// TODO: populate license
// fetch and populate latest_tag
const latestTag = await getGiteaRepoLatestTag(giteaPAT, owner, repo);
if (latestTag) {
repoRecord.latest_tag = {
tag_name: latestTag.tag_name,
url: latestTag.html_url
};
}
return repoRecord;
}
// async function getRepoDetails (octokit: Octokit, repoUrl: string): Promise<RestEndpointMethodTypes["repos"]["get"]["response"]> {
async function getRepoDetails (octokit: Octokit, owner: string, repo: string): Promise<any> {
try {
const response = await octokit.repos.get({
owner: owner,
repo: repo
});
return response.data;
} catch (error) {
console.error('Error fetching repository:', error);
}
}
async function getGiteaRepoDetails (token: string, owner: string, repo: string): Promise<any> {
try {
const response = await axios.get(`${GITEA_BASE_URL}/api/v1/repos/${owner}/${repo}`, {
headers: { Authorization: `token ${token}` }
});
return response.data;
} catch (error) {
console.error('Error fetching repository:', error);
}
}
async function getRepoLatestTag (octokit: Octokit, owner: string, repo: string): Promise<any> {
try {
const response = await octokit.repos.getLatestRelease({
owner: owner,
repo: repo
});
return response.data;
} catch (error: any) {
if ((error as Error).message.includes('Not Found')) {
return null;
}
console.error('Error fetching latest release:', error);
}
}
async function getGiteaRepoLatestTag (token: string, owner: string, repo: string): Promise<any> {
try {
const response = await axios.get(`${GITEA_BASE_URL}/api/v1/repos/${owner}/${repo}/releases/latest`, {
headers: { Authorization: `token ${token}` }
});
return response.data;
} catch (error: any) {
if ((error as Error).message.includes('code 404')) {
return null;
}
console.error('Error fetching latest release:', error);
}
}
function extractOwnerAndRepo (url: string): { owner: string; repo: string } {
// eslint-disable-next-line no-useless-escape
const match = url.match(/(?:github\.com|git\.vdb\.to)\/([^\/]+)\/([^\/]+)(\/|$)/);
if (!match) {
throw new Error(`Unable to extract repo owner and name from the given URL: ${url}`);
}
return { owner: match[1], repo: match[2] };
}
function getArgs (): any {
return yargs(hideBin(process.argv)).parserConfiguration({
'parse-numbers': false
}).usage('Usage: $0 [options]')
.option('config', {
alias: 'c',
describe: 'Config',
type: 'string'
})
.option('repoUrl', {
alias: 'r',
describe: 'Repository URL',
type: 'string',
demandOption: true
})
.option('recordsDir', {
alias: 'd',
describe: 'Directory to export the repo record to',
type: 'string',
demandOption: true
})
.help().argv;
}
main()
.catch(err => {
console.error(err);
});

View File

@ -1,170 +0,0 @@
import yargs from 'yargs';
import fs from 'fs';
import path from 'path';
import assert from 'assert';
import { hideBin } from 'yargs/helpers';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getGasAndFees, getConnectionInfo, txOutput } from '../../src/util';
const recordTypeToRecordField = new Map<string, string>([
['WatcherRecord', 'watcher'],
['SubgraphRecord', 'subgraph'],
['ServiceRecord', 'service']
]);
let registry: Registry;
let fee: any;
let userKey: string;
let bondId: string;
async function main () {
const argv = getArgs();
const { records: recordsDir, config } = argv;
const { services: { registry: registryConfig } } = getConfig(config as string);
if (registryConfig.userKey == null) {
throw new Error('userKey not set in config');
}
if (registryConfig.bondId == null) {
throw new Error('bondId not set in config');
}
let rpcEndpoint, gqlEndpoint, chainId: string;
({ rpcEndpoint, gqlEndpoint, userKey, bondId, chainId } = getConnectionInfo(argv, registryConfig));
registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
fee = getGasAndFees(argv, registryConfig);
await processDir(path.resolve(recordsDir));
}
async function processDir (directoryPath: string): Promise<void> {
const files = fs.readdirSync(directoryPath);
// Check if any JSON record file exists in the directory
if (files.some(file => file.endsWith('.json'))) {
await publishRecordsFromDir(directoryPath);
// Skip further recursion in the current dir
return;
}
// Recursively iterate through subdirectories
for (let i = 0; i < files.length; i++) {
const file = files[i];
const filePath = path.join(directoryPath, file);
if (fs.statSync(filePath).isDirectory()) {
await processDir(filePath);
}
}
}
async function publishRecordsFromDir (recordsDir: string): Promise<void> {
// List record files
const files = fs.readdirSync(recordsDir);
const jsonFiles = files.filter(file => path.extname(file).toLowerCase() === '.json');
// Read record from each JSON file
console.log('**************************************');
console.log(`Publishing records from ${recordsDir}`);
let recordType;
for (let i = 0; i < jsonFiles.length; i++) {
const file = jsonFiles[i];
const filePath = path.resolve(recordsDir, file);
const record = readRecord(filePath);
// Publish record
const result = await registry.setRecord({ privateKey: userKey, record, bondId }, userKey, fee);
console.log(`Published record ${file}`);
txOutput(result, JSON.stringify(result, undefined, 2), '', false);
recordType = record.type;
}
// Check if deployment record files exist
const deploymentRecordsDir = path.resolve(recordsDir, 'deployments');
if (!fs.statSync(deploymentRecordsDir).isDirectory()) {
return;
}
console.log('--------------------------------------');
console.log(`Publishing deployment records from ${deploymentRecordsDir}`);
// List record files
const deploymentFiles = fs.readdirSync(deploymentRecordsDir);
const deploymentJsonFiles = deploymentFiles.filter(file => path.extname(file).toLowerCase() === '.json');
for (let i = 0; i < deploymentJsonFiles.length; i++) {
const file = deploymentJsonFiles[i];
const filePath = path.resolve(deploymentRecordsDir, file);
const deploymentRecord = readRecord(filePath);
// Find record using name and given type
const recordName = deploymentRecord.name;
assert(recordType, 'recordType could not be resolved');
const queryResult = await registry.queryRecords({ type: recordType, name: recordName }, true);
if (queryResult.length === 0) {
throw new Error(`Record not found, type: ${recordType}, name: ${recordName}`);
}
// Assume the first query result
const recordId = queryResult[0].id;
// Set record field to record id
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
deploymentRecord[recordTypeToRecordField.get(recordType)!] = recordId;
// Publish record
const deploymentResult = await registry.setRecord({ privateKey: userKey, record: deploymentRecord, bondId }, userKey, fee);
console.log(`Published record ${file}`);
txOutput(deploymentResult, JSON.stringify(deploymentResult, undefined, 2), '', false);
}
}
function readRecord (filePath: string): any {
let record;
try {
const data = fs.readFileSync(filePath, 'utf8');
record = JSON.parse(data);
} catch (err) {
console.error(`Error reading file ${filePath}:`, err);
}
return record;
}
function getArgs (): any {
return yargs(hideBin(process.argv)).parserConfiguration({
'parse-numbers': false
}).usage('Usage: $0 [options]')
.option('config', {
alias: 'c',
describe: 'Config',
type: 'string',
demandOption: true
})
.option('records', {
alias: 'r',
describe: 'Records dir path',
type: 'string',
demandOption: true
})
.help().argv;
}
main()
.catch(err => {
console.error(err);
})
.finally(() => {
console.log('Done');
});

View File

@ -1,26 +1,28 @@
services: services:
laconicd: laconicd:
restart: unless-stopped restart: unless-stopped
image: cerc/laconicd:local image: cerc-io/laconicd:local-test
command: ["sh", "/docker-entrypoint-scripts.d/create-fixturenet.sh"] command: ["sh", "/docker-entrypoint-scripts.d/create-fixturenet.sh"]
environment:
- TEST_AUCTION_ENABLED
- TEST_REGISTRY_EXPIRY
- LOGLEVEL
volumes: volumes:
- ./laconicd/scripts/init.sh:/docker-entrypoint-scripts.d/create-fixturenet.sh - laconicd/init.sh:/docker-entrypoint-scripts.d/create-fixturenet.sh
healthcheck: healthcheck:
test: ["CMD", "curl", "-v", "http://127.0.0.1:6060"] test: ["CMD", "curl", "-v", "http://127.0.0.1:6060"]
interval: 1s interval: 1s
timeout: 5s timeout: 5s
retries: 30 retries: 30
ports: ports:
- "9473:9473" - "6060"
- "1317:1317" - "26657"
- "26657:26657" - "26656"
- "9473"
- "8545"
- "8546"
- "9090"
- "9091"
- "1317"
cli-test-runner: cli-test-runner:
image: cerc/laconic-registry-cli:local image: cerc/laconic-registry-cli:local-test
depends_on: depends_on:
laconicd: laconicd:
condition: service_healthy condition: service_healthy

View File

@ -1,6 +0,0 @@
/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
module.exports = {
preset: 'ts-jest',
testEnvironment: 'node',
setupFiles: ['dotenv/config']
};

View File

@ -1,48 +1,30 @@
{ {
"name": "@cerc-io/laconic-registry-cli", "name": "@cerc-io/laconic-registry-cli",
"version": "0.2.0", "version": "0.1.7",
"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": "",
"license": "UNLICENSED", "license": "UNLICENSED",
"devDependencies": { "devDependencies": {
"@octokit/rest": "^20.1.1",
"@types/fs-extra": "^9.0.13", "@types/fs-extra": "^9.0.13",
"@types/jest": "^27.4.1",
"@types/js-yaml": "^4.0.5", "@types/js-yaml": "^4.0.5",
"@types/lodash": "^4.14.182", "@types/lodash": "^4.14.182",
"@types/node": "^17.0.25", "@types/node": "^17.0.25",
"@types/yargs": "^17.0.10", "@types/yargs": "^17.0.10",
"@typescript-eslint/eslint-plugin": "^5.47.1",
"@typescript-eslint/parser": "^5.47.1",
"dotenv": "^16.3.2",
"eslint": "^8.35.0",
"eslint-config-semistandard": "^15.0.1",
"eslint-config-standard": "^16.0.3",
"eslint-plugin-import": "^2.27.5",
"eslint-plugin-node": "^11.1.0",
"eslint-plugin-promise": "^5.1.0",
"eslint-plugin-standard": "^5.0.0",
"husky": "^9.0.2",
"jest": "29.0.0",
"ts-jest": "^29.0.2",
"ts-node": "^10.2.1",
"typescript": "^4.6.3" "typescript": "^4.6.3"
}, },
"dependencies": { "dependencies": {
"@cerc-io/registry-sdk": "^0.2.1",
"fs-extra": "^10.1.0", "fs-extra": "^10.1.0",
"@cerc-io/laconic-sdk": "^0.1.13",
"js-yaml": "^3.14.1", "js-yaml": "^3.14.1",
"lodash": "^4.17.21", "lodash": "^4.17.21",
"lodash-clean": "^2.2.3", "lodash-clean": "^2.2.3",
"yargs": "^17.4.1" "yargs": "^17.4.1"
}, },
"scripts": { "scripts": {
"test": "jest --runInBand --verbose test/cli.test.ts",
"lint": "eslint .", "lint": "eslint .",
"clean": "rm -rf ./dist", "clean": "rm -rf ./dist",
"build": "tsc", "build": "tsc"
"prepare": "husky"
}, },
"bin": { "bin": {
"laconic": "bin/laconic" "laconic": "bin/laconic"

View File

@ -0,0 +1,28 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Account, Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'get';
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.');
if (!address && privateKey) {
address = new Account(Buffer.from(privateKey, 'hex')).getCosmosAddress();
}
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const result = await registry.getAccounts([address]);
queryOutput(result,argv.output);
}

View File

@ -7,4 +7,4 @@ export const desc = 'Account operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('account-cmds') return yargs.commandDir('account-cmds')
.demandCommand(); .demandCommand();
}; }

View File

@ -1,7 +1,7 @@
import { Arguments } from 'yargs'; import { Arguments } from 'yargs';
import assert from 'assert'; import assert from 'assert';
import path from 'path'; import path from 'path';
import { Account, createBid, Registry } from '@cerc-io/registry-sdk'; import { Account, createBid, Registry } from '@cerc-io/laconic-sdk';
import { ensureDir } from 'fs-extra'; import { ensureDir } from 'fs-extra';
import fs from 'fs'; import fs from 'fs';
@ -21,16 +21,15 @@ 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: { registry: registryConfig } } = getConfig(argv.config as string); const { services: { cns: cnsConfig } } = getConfig(argv.config as string)
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig); const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.'); assert(restEndpoint, 'Invalid CNS REST endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.'); assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.'); assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.'); assert(chainId, 'Invalid CNS Chain ID.');
const account = new Account(Buffer.from(privateKey, 'hex')); const account = new Account(Buffer.from(privateKey, 'hex'));
await account.init(); const bidderAddress = account.formattedCosmosAddress;
const bidderAddress = account.address;
const bidAmount = `${quantity}${denom}`; const bidAmount = `${quantity}${denom}`;
const { reveal, commitHash } = await createBid(chainId, auctionId, bidderAddress, bidAmount); const { reveal, commitHash } = await createBid(chainId, auctionId, bidderAddress, bidAmount);
@ -40,11 +39,11 @@ export const handler = async (argv: Arguments) => {
await ensureDir(outDirPath); await ensureDir(outDirPath);
fs.writeFileSync(revealFilePath, JSON.stringify(reveal, undefined, 2)); fs.writeFileSync(revealFilePath, JSON.stringify(reveal, undefined, 2));
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId); const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig); const fee = getGasAndFees(argv, cnsConfig);
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}"}`
txOutput(result, revealFile, argv.output, argv.verbose); txOutput(result,revealFile,argv.output,argv.verbose)
}; }

View File

@ -1,7 +1,7 @@
import { Arguments } from 'yargs'; import { Arguments } from 'yargs';
import assert from 'assert'; import assert from 'assert';
import path from 'path'; import path from 'path';
import { Registry } from '@cerc-io/registry-sdk'; import { Registry } from '@cerc-io/laconic-sdk';
import fs from 'fs'; import fs from 'fs';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../../util'; import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../../util';
@ -16,19 +16,19 @@ 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: { registry: registryConfig } } = getConfig(argv.config as string); const { services: { cns: cnsConfig } } = getConfig(argv.config as string)
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig); const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.'); assert(restEndpoint, 'Invalid CNS REST endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.'); assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.'); assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.'); assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId); const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig); const fee = getGasAndFees(argv, cnsConfig);
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);
const success = '{"success": true}'; const success = `{"success":${result.code==0}}`
txOutput(result, success, argv.output, argv.verbose); txOutput(result,success,argv.output,argv.verbose)
}; }

View File

@ -7,9 +7,9 @@ export const desc = 'Auction bid operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.options({ return yargs.options({
'auction-id': { type: 'string' }, 'auction-id': { type: 'string' },
type: { type: 'string' }, 'type': { type: 'string' },
quantity: { type: 'string' }, 'quantity': { type: 'string' },
'file-path': { type: 'string' } 'file-path': { type: 'string' }
}).commandDir('bid-cmds') }).commandDir('bid-cmds')
.demandCommand(); .demandCommand();
}; }

View File

@ -0,0 +1,25 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'get [id]';
export const desc = 'Get auction information.';
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 registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const result = await registry.getAuctionsByIds([id as string]);
queryOutput(result,argv.output)
}

View File

@ -7,4 +7,4 @@ export const desc = 'Auction operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('auction-cmds') return yargs.commandDir('auction-cmds')
.demandCommand(); .demandCommand();
}; }

View File

@ -0,0 +1,30 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../../util';
export const command = 'set [name] [bond-id]';
export const desc = 'Set bond for authority.';
export const handler = async (argv: Arguments) => {
const name = argv.name as string;
const bondId = argv.bondId as string;
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.setAuthorityBond({ name, bondId }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -7,4 +7,4 @@ export const desc = 'Authority bond operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('bond-cmds') return yargs.commandDir('bond-cmds')
.demandCommand(); .demandCommand();
}; }

View File

@ -1,6 +1,6 @@
import { Arguments } from 'yargs'; import { Arguments } from 'yargs';
import assert from 'assert'; import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk'; import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util'; import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
@ -13,24 +13,24 @@ export const builder = {
type: 'string', type: 'string',
default: '' default: ''
} }
}; }
export const handler = async (argv: Arguments) => { export const handler = async (argv: Arguments) => {
const name = argv.name as string; const name = argv.name as string;
const owner = argv.owner as string; const owner = argv.owner as string;
assert(name, 'Invalid authority name.'); assert(name, 'Invalid authority name.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string); const { services: { cns: cnsConfig } } = getConfig(argv.config as string)
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig); const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.'); assert(restEndpoint, 'Invalid CNS REST endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.'); assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.'); assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.'); assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId); const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig); const fee = getGasAndFees(argv, cnsConfig);
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":${result.code==0}}`
txOutput(result, success, argv.output, argv.verbose); txOutput(result,success,argv.output,argv.verbose)
}; }

View File

@ -0,0 +1,25 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'whois [name]';
export const desc = 'Lookup authority information.';
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 registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const result = await registry.lookupAuthorities([name], true);
queryOutput(result,argv.output)
}

View File

@ -7,4 +7,4 @@ export const desc = 'Name authority operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('authority-cmds') return yargs.commandDir('authority-cmds')
.demandCommand(); .demandCommand();
}; }

View File

@ -0,0 +1,36 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees ,txOutput} from '../../../util';
export const command = 'associate';
export const desc = 'Associate record with bond.';
export const builder = {
'bond-id': {
type: 'string'
}
}
export const handler = async (argv: Arguments) => {
const id = argv.id as string;
const bondId = argv.bondId as string;
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.associateBond({ recordId: id, bondId }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -0,0 +1,28 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees,txOutput } from '../../../util';
export const command = 'cancel';
export const desc = 'Cancel bond.';
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.cancelBond({ id }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -0,0 +1,43 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees ,txOutput} from '../../../util';
export const command = 'create';
export const desc = 'Create bond.';
export const builder = {
type: {
type: 'string'
},
quantity: {
type: 'string'
}
}
export const handler = async (argv: Arguments) => {
const { config, verbose } = argv;
const denom = argv.type as string;
const amount = argv.quantity as string;
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const bondId = await registry.getNextBondId(privateKey);
const result = await registry.createBond({ denom, amount }, privateKey, fee);
const jsonString=`{"bondId":"${bondId}"}`
txOutput(result,jsonString,argv.output,argv.verbose)
}

View File

@ -0,0 +1,28 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees ,txOutput} from '../../../util';
export const command = 'dissociate';
export const desc = 'Dissociate record from bond.';
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.dissociateBond({ recordId: id }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -0,0 +1,26 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo ,queryOutput} from '../../../util';
export const command = 'get';
export const desc = 'Get bond.';
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 registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const result = await registry.getBondsByIds([id as string]);
queryOutput(result,argv.output)
}

View File

@ -0,0 +1,30 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo ,queryOutput} from '../../../util';
export const command = 'list';
export const desc = 'List bonds.';
export const builder = {
owner: {
type: 'string'
}
}
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 registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const { owner } = argv;
const result = await registry.queryBonds({ owner });
queryOutput(result,argv.output)
}

View File

@ -0,0 +1,34 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees,txOutput } from '../../../../util';
export const command = 'dissociate';
export const desc = 'Dissociate all records from bond.';
export const builder = {
'bond-id': {
type: 'string'
}
}
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.dissociateRecords({ bondId }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -0,0 +1,39 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees ,txOutput} from '../../../../util';
export const command = 'reassociate';
export const desc = 'Reassociate records with new bond.';
export const builder = {
'old-bond-id': {
type: 'string'
},
'new-bond-id': {
type: 'string'
}
}
export const handler = async (argv: Arguments) => {
const oldBondId = argv.oldBondId as string;
const newBondId = argv.newBondId as string;
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.reassociateRecords({ oldBondId, newBondId }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -7,4 +7,4 @@ export const desc = 'Bond records operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('records-cmds') return yargs.commandDir('records-cmds')
.demandCommand(); .demandCommand();
}; }

View File

@ -0,0 +1,43 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees ,txOutput} from '../../../util';
import { isNil } from 'lodash';
export const command = 'refill';
export const desc = 'Refill bond.';
export const builder = {
type: {
type: 'string'
},
quantity: {
type: 'string'
}
}
export const handler = async (argv: Arguments) => {
const denom = argv.type as string;
const amount = argv.quantity as string;
const id = argv.id as string
assert(id, 'Invalid Bond ID.');
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.refillBond({ id, denom, amount }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -0,0 +1,42 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees,txOutput } from '../../../util';
export const command = 'withdraw';
export const desc = 'Withdraw funds from bond.';
export const builder = {
type: {
type: 'string'
},
quantity: {
type: 'string'
}
}
export const handler = async (argv: Arguments) => {
const denom = argv.type as string;
const amount = argv.quantity as string;
const id = argv.id as string
assert(id, 'Invalid Bond ID.');
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.withdrawBond({ id, denom, amount }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -7,4 +7,4 @@ export const desc = 'Bonds operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('bond-cmds') return yargs.commandDir('bond-cmds')
.demandCommand(); .demandCommand();
}; }

View File

@ -0,0 +1,29 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees ,txOutput} from '../../../util';
export const command = 'delete [name]';
export const desc = 'Delete name (remove name to record ID mapping).';
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.deleteName({ crn: name }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -0,0 +1,31 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo ,queryOutput} from '../../../util';
export const command = 'lookup [name]';
export const desc = 'Lookup name information.';
export const builder = {
history: {
type: 'boolean'
}
}
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 registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const result = await registry.lookupNames([name], argv.history as boolean);
queryOutput(result,argv.output)
}

View File

@ -1,6 +1,6 @@
import { Arguments } from 'yargs'; import { Arguments } from 'yargs';
import assert from 'assert'; import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk'; import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util'; import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
@ -12,16 +12,16 @@ 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: { registry: registryConfig } } = getConfig(argv.config as string); const { services: { cns: cnsConfig } } = getConfig(argv.config as string)
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig); const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.'); assert(restEndpoint, 'Invalid CNS REST endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.'); assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.'); assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId); const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
let result = await registry.resolveNames([name]); let result = await registry.resolveNames([name]);
result = result.filter((v: any) => v); result = result.filter((v: any) => v);
queryOutput(result, argv.output); queryOutput(result, argv.output);
}; }

View File

@ -0,0 +1,31 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees,txOutput } from '../../../util';
export const command = 'set [name] [id]';
export const desc = 'Set name (create name to record ID mapping).';
export const handler = async (argv: Arguments) => {
const name = argv.name as string;
const id = argv.id as string;
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.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid CNS Chain ID.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.setName({ crn: name, cid: id }, privateKey, fee);
const success = `{"success":${result.code==0}}`
txOutput(result,success,argv.output,argv.verbose)
}

View File

@ -6,5 +6,5 @@ export const desc = 'Name operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('name-cmds') return yargs.commandDir('name-cmds')
.demandCommand(); .demandCommand()
}; }

View File

@ -0,0 +1,25 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo ,queryOutput} from '../../../util';
export const command = 'get';
export const desc = 'Get record.';
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 registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const result = await registry.getRecordsByIds([id as string]);
queryOutput(result,argv.output)
}

View File

@ -0,0 +1,59 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo ,queryOutput} from '../../../util';
export const command = 'list';
export const desc = 'List records.';
export const builder = {
'bond-id': {
type: 'string'
},
owner: {
type: 'string'
},
type: {
type: 'string'
},
name: {
type: 'string'
},
all: {
type: 'boolean',
default: false
}
}
export const handler = async (argv: Arguments) => {
const { services: { cns: cnsConfig } } = getConfig(argv.config as string)
const { restEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, cnsConfig);
const { type, name, bondId, owner, all } = argv;
const filters: any = {};
const filterArgs = argv._.slice(3);
for (let i = 0; i < filterArgs.length-1; i+=2) {
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.');
const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
let result = await registry.queryRecords({...filters, type, name}, all as boolean);
// Apply ex post filters.
if (bondId) {
result = result.filter((v: any) => v.bondId === bondId);
}
if (owner) {
result = result.filter((v: any) => v.owners?.find((e: string) => e === owner));
}
queryOutput(result, argv.output)
}

View File

@ -1,8 +1,9 @@
import { Arguments } from 'yargs'; import { Arguments } from 'yargs';
import assert from 'assert'; import assert from 'assert';
import path from 'path';
import yaml from 'js-yaml'; import yaml from 'js-yaml';
import fs from 'fs'; import fs from 'fs';
import { Registry } from '@cerc-io/registry-sdk'; import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getGasAndFees, getConnectionInfo, txOutput } from '../../../util'; import { getConfig, getGasAndFees, getConnectionInfo, txOutput } from '../../../util';
@ -13,19 +14,19 @@ export const desc = 'Register record.';
export const builder = { export const builder = {
'bond-id': { 'bond-id': {
type: 'string' type: 'string'
} },
}; }
export const handler = async (argv: Arguments) => { export const handler = async (argv: Arguments) => {
const { txKey, filename, config } = argv; const { txKey, filename, verbose, config } = argv;
const { services: { registry: registryConfig } } = getConfig(config as string); const { services: { cns: cnsConfig } } = getConfig(config as string)
const { rpcEndpoint, gqlEndpoint, userKey, bondId, chainId } = getConnectionInfo(argv, registryConfig); const { restEndpoint, gqlEndpoint, userKey, bondId, chainId } = getConnectionInfo(argv, cnsConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.'); assert(restEndpoint, 'Invalid CNS REST endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.'); assert(gqlEndpoint, 'Invalid CNS 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 registry Chain ID.'); assert(chainId, 'Invalid CNS Chain ID.');
let file = null; let file = null;
if (filename) { if (filename) {
@ -38,14 +39,14 @@ export const handler = async (argv: Arguments) => {
// Convert sub-objects (other than arrays) to a JSON automatically. // Convert sub-objects (other than arrays) to a JSON automatically.
for (const [k, v] of Object.entries(record)) { for (const [k, v] of Object.entries(record)) {
if (v && typeof v === 'object' && !Array.isArray(v)) { if (v && typeof v === "object" && !Array.isArray(v)) {
record[k] = JSON.stringify(v); record[k] = JSON.stringify(v);
} }
} }
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId); const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig); const fee = getGasAndFees(argv, cnsConfig);
const result = await registry.setRecord({ privateKey: userKey, record, bondId }, txKey || userKey, fee); const result = await registry.setRecord({ privateKey: userKey, record, bondId }, txKey as string, fee);
txOutput(result, JSON.stringify(result, undefined, 2), argv.output, argv.verbose); txOutput(result,JSON.stringify(result.data,undefined,2),argv.output,argv.verbose)
}; }

View File

@ -6,6 +6,6 @@ export const desc = 'Record operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('record-cmds') return yargs.commandDir('record-cmds')
.parserConfiguration({ 'unknown-options-as-args': true }) .parserConfiguration({'unknown-options-as-args': true})
.demandCommand(); .demandCommand()
}; }

View File

@ -0,0 +1,22 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo } from '../../util';
export const command = 'status';
export const desc = 'Get CNS 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 registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const result = await registry.getStatus();
console.log(JSON.stringify(result, undefined, 2));
}

View File

@ -1,6 +1,6 @@
import { Arguments } from 'yargs'; import { Arguments } from 'yargs';
import assert from 'assert'; import assert from 'assert';
import { Account, Registry } from '@cerc-io/registry-sdk'; import { Account, Registry } from '@cerc-io/laconic-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, queryOutput } from '../../../util'; import { getConfig, getConnectionInfo, getGasAndFees, queryOutput } from '../../../util';
@ -15,7 +15,7 @@ export const builder = {
quantity: { quantity: {
type: 'string' type: 'string'
} }
}; }
export const handler = async (argv: Arguments) => { export const handler = async (argv: Arguments) => {
const destinationAddress = argv.address as string; const destinationAddress = argv.address as string;
@ -26,20 +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: { registry: registryConfig } } = getConfig(argv.config as string); const { services: { cns: cnsConfig } } = getConfig(argv.config as string)
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig); const { restEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, cnsConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.'); assert(restEndpoint, 'Invalid CNS REST endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.'); assert(gqlEndpoint, 'Invalid CNS GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.'); assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.'); assert(chainId, 'Invalid CNS Chain ID.');
const account = new Account(Buffer.from(privateKey, 'hex')); const account = new Account(Buffer.from(privateKey, 'hex'));
await account.init(); const fromAddress = account.formattedCosmosAddress;
const fromAddress = account.address;
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId); const registry = new Registry(gqlEndpoint, restEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig); const fee = getGasAndFees(argv, cnsConfig);
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)
}; }

View File

@ -7,4 +7,4 @@ export const desc = 'Tokens operations.';
exports.builder = (yargs: yargs.Argv) => { exports.builder = (yargs: yargs.Argv) => {
return yargs.commandDir('tokens-cmds') return yargs.commandDir('tokens-cmds')
.demandCommand(); .demandCommand();
}; }

23
src/cmds/cns.ts Normal file
View File

@ -0,0 +1,23 @@
import yargs from 'yargs';
export const command = 'cns';
export const desc = 'CNS tools';
exports.builder = (yargs: yargs.Argv) => {
return yargs
.options({
'user-key': { type: 'string' },
'tx-key': { type: 'string' },
'bond-id': { type: 'string' },
'chain-id': { type: 'string' },
'filename': { alias: 'f' },
'id': { type: 'string' },
'address': { type: 'string' },
'gas': { type: 'string' },
'fees': { type: 'string' }
})
.commandDir('cns-cmds')
.demandCommand()
.help()
}

View File

@ -1,28 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Account, Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'get';
export const desc = 'Get account.';
export const handler = async (argv: Arguments) => {
let address = argv.address as string;
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
if (!address && privateKey) {
address = new Account(Buffer.from(privateKey, 'hex')).address;
}
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const result = await registry.getAccounts([address]);
queryOutput(result, argv.output);
};

View File

@ -1,25 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'get [id]';
export const desc = 'Get auction information.';
export const handler = async (argv: Arguments) => {
const { id, config } = argv;
assert(id, 'Invalid auction ID.');
const { services: { registry: registryConfig } } = getConfig(config as string);
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const result = await registry.getAuctionsByIds([id as string]);
queryOutput(result, argv.output);
};

View File

@ -1,30 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../../util';
export const command = 'set [name] [bond-id]';
export const desc = 'Set bond for authority.';
export const handler = async (argv: Arguments) => {
const name = argv.name as string;
const bondId = argv.bondId as string;
assert(name, 'Invalid authority name.');
assert(bondId, 'Invalid Bond ID.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig);
const result = await registry.setAuthorityBond({ name, bondId }, privateKey, fee);
const success = '{"success": true}';
txOutput(result, success, argv.output, argv.verbose);
};

View File

@ -1,25 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'whois [name]';
export const desc = 'Lookup authority information.';
export const handler = async (argv: Arguments) => {
const name = argv.name as string;
assert(name, 'Invalid authority name.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const result = await registry.lookupAuthorities([name], true);
queryOutput(result, argv.output);
};

View File

@ -1,35 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
export const command = 'associate';
export const desc = 'Associate record with bond.';
export const builder = {
'bond-id': {
type: 'string'
}
};
export const handler = async (argv: Arguments) => {
const id = argv.id as string;
const bondId = argv.bondId as string;
assert(id, 'Invalid Record ID.');
assert(bondId, 'Invalid Bond ID.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
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);
};

View File

@ -1,27 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
export const command = 'cancel';
export const desc = 'Cancel bond.';
export const handler = async (argv: Arguments) => {
const id = argv.id as string;
assert(id, 'Invalid Bond ID.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig);
const result = await registry.cancelBond({ id }, privateKey, fee);
const success = '{"success": true}';
txOutput(result, success, argv.output, argv.verbose);
};

View File

@ -1,42 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
export const command = 'create';
export const desc = 'Create bond.';
export const builder = {
type: {
type: 'string'
},
quantity: {
type: 'string'
}
};
export const handler = async (argv: Arguments) => {
const { config } = argv;
const denom = argv.type as string;
const amount = argv.quantity as string;
assert(denom, 'Invalid Type.');
assert(amount, 'Invalid Quantity.');
const { services: { registry: registryConfig } } = getConfig(config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig);
const bondId = await registry.getNextBondId(privateKey);
const result = await registry.createBond({ denom, amount }, privateKey, fee);
const jsonString = `{"bondId":"${bondId}"}`;
txOutput(result, jsonString, argv.output, argv.verbose);
};

View File

@ -1,27 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
export const command = 'dissociate';
export const desc = 'Dissociate record from bond.';
export const handler = async (argv: Arguments) => {
const id = argv.id as string;
assert(id, 'Invalid Record ID.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
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);
};

View File

@ -1,26 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'get';
export const desc = 'Get bond.';
export const handler = async (argv: Arguments) => {
const { id, config } = argv;
console.assert(id, 'Bond Id is required.');
const { services: { registry: registryConfig } } = getConfig(config as string);
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const result = await registry.getBondsByIds([id as string]);
queryOutput(result, argv.output);
};

View File

@ -1,30 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'list';
export const desc = 'List bonds.';
export const builder = {
owner: {
type: 'string'
}
};
export const handler = async (argv: Arguments) => {
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const { owner } = argv;
const result = await registry.queryBonds({ owner });
queryOutput(result, argv.output);
};

View File

@ -1,33 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../../util';
export const command = 'dissociate';
export const desc = 'Dissociate all records from bond.';
export const builder = {
'bond-id': {
type: 'string'
}
};
export const handler = async (argv: Arguments) => {
const bondId = argv.bondId as string;
assert(bondId, 'Invalid Bond ID.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig);
const result = await registry.dissociateRecords({ bondId }, privateKey, fee);
const success = '{"success": true}';
txOutput(result, success, argv.output, argv.verbose);
};

View File

@ -1,38 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../../util';
export const command = 'reassociate';
export const desc = 'Reassociate records with new bond.';
export const builder = {
'old-bond-id': {
type: 'string'
},
'new-bond-id': {
type: 'string'
}
};
export const handler = async (argv: Arguments) => {
const oldBondId = argv.oldBondId as string;
const newBondId = argv.newBondId as string;
assert(oldBondId, 'Invalid Old Bond ID.');
assert(newBondId, 'Invalid New Bond ID.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
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);
};

View File

@ -1,41 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
export const command = 'refill';
export const desc = 'Refill bond.';
export const builder = {
type: {
type: 'string'
},
quantity: {
type: 'string'
}
};
export const handler = async (argv: Arguments) => {
const denom = argv.type as string;
const amount = argv.quantity as string;
const id = argv.id as string;
assert(id, 'Invalid Bond ID.');
assert(denom, 'Invalid Type.');
assert(amount, 'Invalid Quantity.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
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);
};

View File

@ -1,41 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
export const command = 'withdraw';
export const desc = 'Withdraw funds from bond.';
export const builder = {
type: {
type: 'string'
},
quantity: {
type: 'string'
}
};
export const handler = async (argv: Arguments) => {
const denom = argv.type as string;
const amount = argv.quantity as string;
const id = argv.id as string;
assert(id, 'Invalid Bond ID.');
assert(denom, 'Invalid Type.');
assert(amount, 'Invalid Quantity.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
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);
};

View File

@ -1,28 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
export const command = 'delete [name]';
export const desc = 'Delete name (remove name to record ID mapping).';
export const handler = async (argv: Arguments) => {
const name = argv.name as string;
assert(name, 'Invalid Name.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig);
const result = await registry.deleteName({ lrn: name }, privateKey, fee);
const success = '{"success": true}';
txOutput(result, success, argv.output, argv.verbose);
};

View File

@ -1,31 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'lookup [name]';
export const desc = 'Lookup name information.';
export const builder = {
history: {
type: 'boolean'
}
};
export const handler = async (argv: Arguments) => {
const name = argv.name as string;
assert(name, 'Invalid Name.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const result = await registry.lookupNames([name], argv.history as boolean);
queryOutput(result, argv.output);
};

View File

@ -1,30 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, getGasAndFees, txOutput } from '../../../util';
export const command = 'set [name] [id]';
export const desc = 'Set name (create name to record ID mapping).';
export const handler = async (argv: Arguments) => {
const name = argv.name as string;
const id = argv.id as string;
assert(name, 'Invalid Name.');
assert(id, 'Invalid Record ID.');
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, privateKey, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(privateKey, 'Invalid Transaction Key.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const fee = getGasAndFees(argv, registryConfig);
const result = await registry.setName({ lrn: name, cid: id }, privateKey, fee);
const success = '{"success": true}';
txOutput(result, success, argv.output, argv.verbose);
};

View File

@ -1,25 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'get';
export const desc = 'Get record.';
export const handler = async (argv: Arguments) => {
const { id, config } = argv;
assert(id, 'Invalid Record ID.');
const { services: { registry: registryConfig } } = getConfig(config as string);
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const result = await registry.getRecordsByIds([id as string]);
queryOutput(result, argv.output);
};

View File

@ -1,59 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo, queryOutput } from '../../../util';
export const command = 'list';
export const desc = 'List records.';
export const builder = {
'bond-id': {
type: 'string'
},
owner: {
type: 'string'
},
type: {
type: 'string'
},
name: {
type: 'string'
},
all: {
type: 'boolean',
default: false
}
};
export const handler = async (argv: Arguments) => {
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
const { type, name, bondId, owner, all } = argv;
const filters: any = {};
const filterArgs = argv._.slice(3);
for (let i = 0; i < filterArgs.length - 1; i += 2) {
filters[String(filterArgs[i]).replace(/^-+/, '')] = filterArgs[i + 1];
}
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
let result = await registry.queryRecords({ ...filters, type, name }, all as boolean);
// Apply ex post filters.
if (bondId) {
result = result.filter((v: any) => v.bondId === bondId);
}
if (owner) {
result = result.filter((v: any) => v.owners?.find((e: string) => e === owner));
}
queryOutput(result, argv.output);
};

View File

@ -1,22 +0,0 @@
import { Arguments } from 'yargs';
import assert from 'assert';
import { Registry } from '@cerc-io/registry-sdk';
import { getConfig, getConnectionInfo } from '../../util';
export const command = 'status';
export const desc = 'Get registry status.';
export const handler = async (argv: Arguments) => {
const { services: { registry: registryConfig } } = getConfig(argv.config as string);
const { rpcEndpoint, gqlEndpoint, chainId } = getConnectionInfo(argv, registryConfig);
assert(rpcEndpoint, 'Invalid registry RPC endpoint.');
assert(gqlEndpoint, 'Invalid registry GQL endpoint.');
assert(chainId, 'Invalid registry Chain ID.');
const registry = new Registry(gqlEndpoint, rpcEndpoint, chainId);
const result = await registry.getStatus();
console.log(JSON.stringify(result, undefined, 2));
};

View File

@ -1,23 +0,0 @@
import yargs from 'yargs';
export const command = 'registry';
export const desc = 'Registry tools';
exports.builder = (yargs: yargs.Argv) => {
return yargs
.options({
'user-key': { type: 'string' },
'tx-key': { type: 'string' },
'bond-id': { type: 'string' },
'chain-id': { type: 'string' },
filename: { alias: 'f' },
id: { type: 'string' },
address: { type: 'string' },
gas: { type: 'string' },
fees: { type: 'string' }
})
.commandDir('registry-cmds')
.demandCommand()
.help();
};

View File

@ -1,7 +1,6 @@
import yargs from 'yargs/yargs'; import yargs from 'yargs/yargs';
import { hideBin } from 'yargs/helpers'; import { hideBin } from 'yargs/helpers';
// eslint-disable-next-line no-unused-expressions
yargs(hideBin(process.argv)) yargs(hideBin(process.argv))
.options({ .options({
verbose: { verbose: {

View File

@ -1 +0,0 @@
declare module 'lodash-clean';

View File

@ -1,6 +0,0 @@
{
"name": "common",
"version": "0.1.0",
"license": "AGPL-3.0",
"typings": "main.d.ts"
}

View File

@ -1,4 +1,4 @@
import { Arguments } from 'yargs'; import { Arguments } from "yargs";
import clean from 'lodash-clean'; import clean from 'lodash-clean';
export const getConnectionInfo = (argv: Arguments, config: any) => { export const getConnectionInfo = (argv: Arguments, config: any) => {

View File

@ -1,9 +1,9 @@
import yaml from 'js-yaml'; import yaml from 'js-yaml'
import fs from 'fs'; import fs from 'fs'
import path from 'path'; import path from 'path'
export const getConfig = (configFilePath: string): any => { export const getConfig = (configFilePath: string): any => {
const resolvedFilePath = path.resolve(process.cwd(), configFilePath); const resolvedFilePath = path.resolve(process.cwd(), configFilePath);
const configFile = fs.readFileSync(resolvedFilePath, 'utf-8'); const configFile = fs.readFileSync(resolvedFilePath, 'utf-8')
return yaml.load(configFile); return yaml.load(configFile);
}; };

View File

@ -1,4 +1,3 @@
/* eslint-disable @typescript-eslint/no-unused-vars */
import assert from 'assert'; import assert from 'assert';
import { Arguments } from 'yargs'; import { Arguments } from 'yargs';
@ -10,10 +9,7 @@ export const parseGasAndFees = (gas: string, fees = '') => {
.filter(([_, amount, denom]) => (denom && amount)) .filter(([_, amount, denom]) => (denom && amount))
.map(([_, amount, denom]) => ({ denom, amount })); .map(([_, amount, denom]) => ({ denom, amount }));
return { return { amount, denom, gas };
amount: [{ denom, amount }],
gas
};
}; };
export const getGasAndFees = (argv: Arguments, config: any = {}) => { export const getGasAndFees = (argv: Arguments, config: any = {}) => {

View File

@ -1,22 +1,22 @@
export const txOutput = (result:any, msg:string, output:unknown, verbose:unknown) => { export const txOutput = (result:any,msg:string,output:unknown,verbose:unknown) => {
if (output === 'json') { if (output=="json"){
console.log(verbose ? JSON.parse(JSON.stringify(result)) : JSON.parse(msg)); console.log(verbose ? JSON.parse(JSON.stringify(result)) : JSON.parse(msg));
} else { } else {
console.log(verbose ? JSON.stringify(result, undefined, 2) : msg); console.log(verbose ? JSON.stringify(result,undefined,2) : msg);
} }
}; };
export const queryOutput = (result: any, output: unknown) => { export const queryOutput = (result: any, output: unknown) => {
if (output === 'json') { if (output=="json"){
console.log(JSON.parse(JSON.stringify(result))); console.log(JSON.parse(JSON.stringify(result)));
} else { } else {
console.log(JSON.stringify(result, (key, value) => { console.log(JSON.stringify(result, (key, value) => {
try { try {
return JSON.parse(value); return JSON.parse(value)
} catch (e) { } catch (e) {
return value; return value;
} }
}, 2)); }, 2));
} }
}; }

View File

@ -1,34 +0,0 @@
## Run CLI tests
* Follow the project `Setup` and `Account Setup` from root [README](./../README.md)
* Add laconic cmd to path
```bash
export PATH="$PWD/bin:$PATH"
```
* Create a .env file using [.env.example](./.env.example):
```bash
cp .env.example .env
```
* Get account address of test account:
```bash
laconicd keys list --keyring-backend test
# - address: laconic10er85pyd7ukw732e88fzv7k0jq205764hye2dx
# name: alice
# pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AsDoWlNIr3W013pOiwmopaB/SaWQj6r3g56xb2d9GxYK"}'
# type: local
```
Use the `address` field from the result and assign it in `TEST_ACCOUNT` field of `.env` file
* Run CLI tests:
```bash
yarn test
```

View File

@ -1,527 +0,0 @@
import fs from 'fs';
import assert from 'assert';
import { spawnSync } from 'child_process';
import {
CHAIN_ID,
TOKEN_TYPE,
AUCTION_COMMIT_DURATION,
AUCTION_REVEAL_DURATION,
delay,
checkResultAndRetrieveOutput,
createBond,
getBondObj,
getAccountObj,
getRecordObj,
getAuthorityObj,
getAuctionObj,
getBidObj
} from './helpers';
describe('Test laconic CLI commands', () => {
test('laconic', async () => {
const result = spawnSync('laconic');
expect(result.status).toBe(1);
const output = result.stdout.toString().trim();
const errorOutput = result.stderr.toString().trim();
// Expect error with usage string
expect(output).toBe('');
expect(errorOutput).toContain('laconic <command>');
});
test('laconic registry', async () => {
const result = spawnSync('laconic', ['registry']);
expect(result.status).toBe(1);
const output = result.stdout.toString().trim();
const errorOutput = result.stderr.toString().trim();
// Expect error with usage string
expect(output).toBe('');
expect(errorOutput).toContain('laconic registry');
expect(errorOutput).toContain('Registry tools');
expect(errorOutput).toContain('Commands:');
});
// TODO: Break up tests into separate files
// TODO: Add tests for registry commands with all available flags
describe('laconic registry commands', () => {
const testAccount = process.env.TEST_ACCOUNT;
assert(testAccount, 'TEST_ACCOUNT not set in env');
const testAccount2 = 'laconic1pmuxrcnuhhf8qdllzuf2ctj2tnwwcg6yswqnyd';
const initialAccountBalance = Number('100000000000000000000000000');
const testAuthorityName = 'laconic';
const testRecordFilePath = 'test/data/watcher-record.yml';
let testAuctionId: string, testRecordId: string, testRecordBondId: string;
test('laconic registry status', async () => {
const result = spawnSync('laconic', ['registry', 'status']);
const outputObj = checkResultAndRetrieveOutput(result);
// Expect output object to have registry status props
expect(outputObj).toHaveProperty('version');
expect(outputObj).toHaveProperty('node');
expect(outputObj).toHaveProperty('node.network', CHAIN_ID);
expect(outputObj).toHaveProperty('sync');
expect(Number(outputObj.sync.latest_block_height)).toBeGreaterThan(0);
expect(outputObj).toHaveProperty('validator');
expect(outputObj).toHaveProperty('validators');
expect(outputObj).toHaveProperty('num_peers');
expect(outputObj).toHaveProperty('peers');
expect(outputObj).toHaveProperty('disk_usage');
});
describe('Bond operations', () => {
const bondOwner = testAccount;
let bondBalance = 1000000000;
let bondId: string;
test('laconic registry bond create --type <type> --quantity <quantity> --gas <gas> --fees <fees>', async () => {
const result = spawnSync('laconic', ['registry', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondBalance.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expect output object to have resultant bond id
expect(outputObj.bondId).toBeDefined();
bondId = outputObj.bondId;
});
test('laconic registry bond list', async () => {
const result = spawnSync('laconic', ['registry', 'bond', 'list']);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected bond
const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toEqual(expectedBond);
});
test('laconic registry bond list --owner <owner_address>', async () => {
const result = spawnSync('laconic', ['registry', 'bond', 'list', '--owner', bondOwner]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected bond
const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toEqual(expectedBond);
});
test('laconic registry bond get --id <bond_id>', async () => {
const result = spawnSync('laconic', ['registry', 'bond', 'get', '--id', bondId]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected bond
const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toEqual(expectedBond);
});
test('laconic registry bond refill --id <bond_id> --type <type> --quantity <quantity>', async () => {
const bondRefillAmount = 1000;
bondBalance += bondRefillAmount;
const result = spawnSync('laconic', ['registry', 'bond', 'refill', '--id', bondId, '--type', TOKEN_TYPE, '--quantity', bondRefillAmount.toString()]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
// Check updated bond
const bondResult = spawnSync('laconic', ['registry', 'bond', 'get', '--id', bondId]);
const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
// Expected bond
const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
expect(bondOutputObj.length).toEqual(1);
expect(bondOutputObj[0]).toEqual(expectedBond);
});
test('laconic registry bond withdraw --id <bond_id> --type <type> --quantity <quantity>', async () => {
const bondWithdrawAmount = 500;
bondBalance -= bondWithdrawAmount;
const result = spawnSync('laconic', ['registry', 'bond', 'withdraw', '--id', bondId, '--type', TOKEN_TYPE, '--quantity', bondWithdrawAmount.toString()]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
// Check updated bond
const bondResult = spawnSync('laconic', ['registry', 'bond', 'get', '--id', bondId]);
const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
// Expected bond
const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
// Expect balance to be deducted
expect(bondOutputObj.length).toEqual(1);
expect(bondOutputObj[0]).toEqual(expectedBond);
});
test('laconic registry bond cancel --id <bond_id>', async () => {
const result = spawnSync('laconic', ['registry', 'bond', 'cancel', '--id', bondId]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
// Check updated bond
const bondResult = spawnSync('laconic', ['registry', 'bond', 'get', '--id', bondId]);
const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
// Expect empty object
expect(bondOutputObj.length).toEqual(1);
expect(bondOutputObj[0]).toEqual(null);
});
});
describe('Account and tokens operations', () => {
let balanceBeforeSend: number;
test('laconic registry account get --address <account_address>', async () => {
const result = spawnSync('laconic', ['registry', 'account', 'get', '--address', testAccount]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected account
const expectedAccount = getAccountObj({ address: testAccount });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toMatchObject(expectedAccount);
expect(outputObj[0].number).toBeDefined();
expect(outputObj[0].sequence).toBeDefined();
balanceBeforeSend = Number(outputObj[0].balance[0].quantity);
expect(balanceBeforeSend).toBeGreaterThan(0);
expect(balanceBeforeSend).toBeLessThan(initialAccountBalance);
});
test('laconic registry tokens send --address <account_address> --type <token_type> --quantity <quantity>', async () => {
const sendAmount = 1000000000;
const balanceAfterSend = balanceBeforeSend - sendAmount;
const result = spawnSync('laconic', ['registry', 'tokens', 'send', '--address', testAccount2, '--type', TOKEN_TYPE, '--quantity', sendAmount.toString()]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected acconts
const expectedAccounts = [
getAccountObj({ address: testAccount, balance: balanceAfterSend }),
getAccountObj({ address: testAccount2, balance: sendAmount })
];
expect(outputObj.length).toEqual(2);
expect(outputObj).toMatchObject(expectedAccounts);
});
});
describe('Record operations', () => {
const gas = 250000;
const bondBalance = 1000000000;
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
({ bondId: testRecordBondId } = createBond(bondBalance));
const result = spawnSync('laconic', ['registry', 'record', 'publish', '--filename', testRecordFilePath, '--bond-id', testRecordBondId, '--gas', gas.toString()]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expect output object to resultant bond id
expect(outputObj.id).toBeDefined();
testRecordId = outputObj.id;
});
test('laconic registry record list', async () => {
const result = spawnSync('laconic', ['registry', 'record', 'list']);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected record
const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId, recordId: testRecordId, names: null });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toMatchObject(expectedRecord);
expect(outputObj[0].createTime).toBeDefined();
expect(outputObj[0].expiryTime).toBeDefined();
expect(outputObj[0].owners).toBeDefined();
expect(outputObj[0].owners.length).toEqual(1);
});
test('laconic registry record get --id <record_id>', async () => {
const result = spawnSync('laconic', ['registry', 'record', 'get', '--id', testRecordId]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected record
const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId, recordId: testRecordId, names: null });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toMatchObject(expectedRecord);
});
describe('Bond records operations', () => {
let testRecordBondId2: string;
test('laconic registry bond dissociate --id <record_id>', async () => {
const result = spawnSync('laconic', ['registry', 'bond', 'dissociate', '--id', testRecordId]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
const recordResult = spawnSync('laconic', ['registry', 'record', 'get', '--id', testRecordId]);
const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
// Expected record
const expectedRecord = getRecordObj(testRecordFilePath, { bondId: '', recordId: testRecordId, names: null });
expect(recordOutputObj.length).toEqual(1);
expect(recordOutputObj[0]).toMatchObject(expectedRecord);
});
test('laconic registry bond associate --id <record_id> --bond-id <bond_id>', async () => {
// Create a new bond to be associated with the record
({ bondId: testRecordBondId2 } = createBond(bondBalance));
const result = spawnSync('laconic', ['registry', 'bond', 'associate', '--id', testRecordId, '--bond-id', testRecordBondId2]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
const recordResult = spawnSync('laconic', ['registry', 'record', 'get', '--id', testRecordId]);
const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
// Expected record
const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId2, recordId: testRecordId, names: null });
expect(recordOutputObj.length).toEqual(1);
expect(recordOutputObj[0]).toMatchObject(expectedRecord);
});
test('laconic registry bond records reassociate --old-bond-id <old_bond_id> --new-bond-id <new_bond_id>', async () => {
const result = spawnSync('laconic', ['registry', 'bond', 'records', 'reassociate', '--old-bond-id', testRecordBondId2, '--new-bond-id', testRecordBondId]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
const recordResult = spawnSync('laconic', ['registry', 'record', 'get', '--id', testRecordId]);
const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
// Expected record
const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId, recordId: testRecordId, names: null });
expect(recordOutputObj.length).toEqual(1);
expect(recordOutputObj[0]).toMatchObject(expectedRecord);
});
});
});
describe('Name authority operations (pre auction)', () => {
test('laconic registry authority reserve <authority_name>', async () => {
const result = spawnSync('laconic', ['registry', 'authority', 'reserve', testAuthorityName]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expect result
expect(outputObj).toEqual({ success: true });
});
test('laconic registry authority whois <authority_name>', async () => {
const result = spawnSync('laconic', ['registry', 'authority', 'whois', testAuthorityName]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected authority (still in auction)
const expectedAuthority = getAuthorityObj({ owner: '', status: 'auction', auction: getAuctionObj({ owner: testAccount }) });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toMatchObject(expectedAuthority);
expect(outputObj[0].expiryTime).toBeDefined();
expect(outputObj[0].height).toBeGreaterThan(0);
testAuctionId = outputObj[0].auction.id;
});
});
describe('Auction operations', () => {
const bidAmount = 25000000;
let bidRevealFilePath: string;
test('laconic registry auction get <auction_id>', async () => {
const result = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected auction (still in commit stage)
const expectedAuction = getAuctionObj({ owner: testAccount, status: 'commit' });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toMatchObject(expectedAuction);
});
test('laconic registry auction bid commit <auction_id> <quantity> <type>', async () => {
const result = spawnSync('laconic', ['registry', 'auction', 'bid', 'commit', testAuctionId, bidAmount.toString(), TOKEN_TYPE]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj.reveal_file).toBeDefined();
bidRevealFilePath = outputObj.reveal_file;
});
test('laconic registry auction bid reveal <auction_id> <file_path>', async () => {
// Wait for auction commits duration (60s)
await delay(AUCTION_COMMIT_DURATION * 1000);
const auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
const expectedAuction = getAuctionObj({ owner: testAccount, status: 'reveal' });
const expectedBid = getBidObj({ bidder: testAccount });
expect(auctionOutputObj[0]).toMatchObject(expectedAuction);
expect(auctionOutputObj[0].bids[0]).toMatchObject(expectedBid);
// Reveal bid
const result = spawnSync('laconic', ['registry', 'auction', 'bid', 'reveal', testAuctionId, bidRevealFilePath]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
const revealObject = JSON.parse(fs.readFileSync(bidRevealFilePath, 'utf8'));
expect(revealObject).toMatchObject({
chainId: CHAIN_ID,
auctionId: testAuctionId,
bidderAddress: testAccount,
bidAmount: `${bidAmount}photon`
});
}, (AUCTION_COMMIT_DURATION + 5) * 1000);
});
describe('Name authority operations (post auction)', () => {
const testSubAuthorityName = 'echo.laconic';
const testSubAuthorityName2 = 'kube.laconic';
test('laconic registry authority whois <authority_name>', async () => {
// Wait for auction reveals duration (60s)
await delay(AUCTION_REVEAL_DURATION * 1000);
const result = spawnSync('laconic', ['registry', 'authority', 'whois', testAuthorityName]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected authority (active)
const expectedAuthority = getAuthorityObj({ owner: testAccount, status: 'active', auction: null });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toMatchObject(expectedAuthority);
}, (AUCTION_REVEAL_DURATION + 5) * 1000);
test('laconic registry authority bond set laconic <bond_id>', async () => {
// Create a new bond to be set on the authority
const bondBalance = 1000000000;
const { bondId } = createBond(bondBalance);
const result = spawnSync('laconic', ['registry', 'authority', 'bond', 'set', testAuthorityName, bondId]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
// Check updated authority
const authorityResult = spawnSync('laconic', ['registry', 'authority', 'whois', testAuthorityName]);
const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
// Expected authority (active with bond)
const expectedAuthority = getAuthorityObj({ owner: testAccount, status: 'active', auction: null, bondId: bondId });
expect(authorityOutputObj.length).toEqual(1);
expect(authorityOutputObj[0]).toMatchObject(expectedAuthority);
});
test('laconic registry authority reserve <sub_authority> (same owner)', async () => {
const result = spawnSync('laconic', ['registry', 'authority', 'reserve', testSubAuthorityName]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
// Check updated authority
const authorityResult = spawnSync('laconic', ['registry', 'authority', 'whois', testSubAuthorityName]);
const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
// Expected authority (active with bond)
const expectedAuthority = getAuthorityObj({ owner: testAccount, status: 'active', auction: null });
expect(authorityOutputObj.length).toEqual(1);
expect(authorityOutputObj[0]).toMatchObject(expectedAuthority);
});
test('laconic registry authority reserve <sub_authority> --owner <owner_address> (different owner)', async () => {
const result = spawnSync('laconic', ['registry', 'authority', 'reserve', testSubAuthorityName2, '--owner', testAccount2]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
// Check updated authority
const authorityResult = spawnSync('laconic', ['registry', 'authority', 'whois', testSubAuthorityName2]);
const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
// Expected authority (active with bond)
const expectedAuthority = getAuthorityObj({ owner: testAccount2, status: 'active', auction: null });
expect(authorityOutputObj.length).toEqual(1);
expect(authorityOutputObj[0]).toMatchObject(expectedAuthority);
});
});
describe('Name operations', () => {
const testName = 'lrn://laconic/watcher/erc20';
test('laconic registry name set <name> <record_id>', async () => {
const result = spawnSync('laconic', ['registry', 'name', 'set', testName, testRecordId]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
});
test('laconic registry name lookup <name>', async () => {
const result = spawnSync('laconic', ['registry', 'name', 'lookup', testName]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toMatchObject({ latest: { id: testRecordId } });
});
test('laconic registry name resolve <name>', async () => {
const result = spawnSync('laconic', ['registry', 'name', 'resolve', testName]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected resolved record
const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId, recordId: testRecordId, names: [testName] });
expect(outputObj.length).toEqual(1);
expect(outputObj[0]).toMatchObject(expectedRecord);
});
test('laconic registry name delete <name>', async () => {
const result = spawnSync('laconic', ['registry', 'name', 'delete', testName]);
const outputObj = checkResultAndRetrieveOutput(result);
// Expected output
expect(outputObj).toEqual({ success: true });
// Check that name doesn't resolve
const resolveResult = spawnSync('laconic', ['registry', 'name', 'resolve', testName]);
const resolveOutputObj = checkResultAndRetrieveOutput(resolveResult);
expect(resolveOutputObj.length).toEqual(0);
});
});
});
});

View File

@ -1,7 +0,0 @@
record:
type: WebsiteRegistrationRecord
url: 'https://cerc.io'
repo_registration_record_cid: QmSnuWmxptJZdLJpKRarxBMS2Ju2oANVrgbr2xWbie9b2D
build_artifact_cid: QmP8jTG1m9GSDJLCbeWhVSVgEzCPPwXRdCRuJtQ5Tz9Kc9
tls_cert_cid: QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR
version: 1.0.23

View File

@ -1,120 +0,0 @@
import fs from 'fs';
import yaml from 'js-yaml';
import { SpawnSyncReturns, spawnSync } from 'child_process';
export const CHAIN_ID = 'laconic_9000-1';
export const TOKEN_TYPE = 'photon';
export const AUCTION_FEES = {
commit: 1000000,
reveal: 1000000,
minimumBid: 5000000
};
export const AUCTION_COMMIT_DURATION = 60; // 60s
export const AUCTION_REVEAL_DURATION = 60; // 60s
export function checkResultAndRetrieveOutput (result: SpawnSyncReturns<Buffer>): any {
expect(result.status).toBe(0);
const errorOutput = result.stderr.toString().trim();
expect(errorOutput).toBe('');
const output = result.stdout.toString().trim();
expect(output.length).toBeGreaterThan(0);
return JSON.parse(output);
}
export function createBond (quantity: number): { bondId: string } {
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();
return JSON.parse(output);
}
export function getBondObj (params: { id: string, owner: string, balance: number}): any {
return {
id: params.id,
owner: params.owner,
balance: [
{
type: TOKEN_TYPE,
quantity: params.balance
}
]
};
}
export function getAccountObj (params: { address: string, balance?: number }): any {
const balanceObj: any = { type: TOKEN_TYPE };
if (params.balance) {
balanceObj.quantity = params.balance;
}
return {
address: params.address,
balance: [balanceObj]
};
}
export function getRecordObj (recordFilePath: string, params: { bondId: string, recordId: string, names: any }): any {
const recordContent = yaml.load(fs.readFileSync(recordFilePath, 'utf8')) as any;
return {
id: params.recordId,
names: params.names,
bondId: params.bondId,
attributes: recordContent.record
};
}
export function getAuthorityObj (params: { owner: string, status: string, auction: any, bondId?: string }): any {
return {
ownerAddress: params.owner,
status: params.status,
bondId: params.bondId || '',
auction: params.auction
};
}
export function getAuctionObj (params: { owner: string, status?: string }): any {
return {
status: params.status || 'commit',
ownerAddress: params.owner,
commitFee: {
type: TOKEN_TYPE,
quantity: AUCTION_FEES.commit
},
revealFee: {
type: TOKEN_TYPE,
quantity: AUCTION_FEES.reveal
},
minimumBid: {
type: TOKEN_TYPE,
quantity: AUCTION_FEES.minimumBid
},
winnerAddress: ''
};
}
export function getBidObj (params: { bidder: string, status?: string }): any {
return {
bidderAddress: params.bidder,
status: params.status || 'commit',
commitFee: {
type: TOKEN_TYPE,
quantity: AUCTION_FEES.commit
},
revealFee: {
type: TOKEN_TYPE,
quantity: AUCTION_FEES.reveal
},
bidAmount: {
type: '',
quantity: 0
}
};
}
export async function delay (ms: number): Promise<any> {
return new Promise((resolve) => setTimeout(resolve, ms));
}

View File

@ -1,34 +0,0 @@
#!/usr/bin/env bash
# Get the key from laconicd
laconicd_key=$(yes | docker compose exec laconicd laconicd keys export alice --keyring-backend test --unarmored-hex --unsafe)
# Get the fixturenet account address
laconicd_account_address=$(docker compose exec laconicd laconicd keys list --keyring-backend test | awk '/- address:/ {print $3}')
# Set parameters for the test suite
cosmos_chain_id=laconic_9000-1
laconicd_rpc_endpoint=http://127.0.0.1:26657
laconicd_gql_endpoint=http://127.0.0.1:9473/api
# Create the required config
config_file="config.yml"
config=$(cat <<EOL
services:
registry:
rpcEndpoint: $laconicd_rpc_endpoint
gqlEndpoint: $laconicd_gql_endpoint
userKey: $laconicd_key
bondId:
chainId: $cosmos_chain_id
gas: 200000
fees: 200000photon
EOL
)
echo "$config" > "$config_file"
# Wait for the laconid endpoint to come up
docker compose exec laconicd sh -c "curl --retry 10 --retry-delay 3 --retry-connrefused http://127.0.0.1:9473/api"
# Run tests
TEST_ACCOUNT=$laconicd_account_address yarn test

View File

@ -30,10 +30,7 @@
// "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */ // "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */
// "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */ // "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */
// "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */ // "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */
"typeRoots": [ // "typeRoots": [], /* Specify multiple folders that act like `./node_modules/@types`. */
"node_modules/@types",
"src/types"
],
// "types": [], /* Specify type package names to be included without being referenced in a source file. */ // "types": [], /* Specify type package names to be included without being referenced in a source file. */
// "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */ // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */
// "resolveJsonModule": true, /* Enable importing .json files */ // "resolveJsonModule": true, /* Enable importing .json files */
@ -100,7 +97,5 @@
/* Completeness */ /* Completeness */
// "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */ // "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */
"skipLibCheck": true /* Skip type checking all .d.ts files. */ "skipLibCheck": true /* Skip type checking all .d.ts files. */
}, }
"include": ["src"],
"exclude": ["test"]
} }

3950
yarn.lock

File diff suppressed because it is too large Load Diff