Nabarun
c770d14bd9
Co-authored-by: Prathamesh Musale <prathamesh.musale0@gmail.com> Reviewed-on: #84 Co-authored-by: Nabarun <nabarun@deepstacksoft.com> Co-committed-by: Nabarun <nabarun@deepstacksoft.com>
969 lines
41 KiB
TypeScript
969 lines
41 KiB
TypeScript
import fs from 'fs';
|
|
import assert from 'assert';
|
|
import { spawnSync } from 'child_process';
|
|
|
|
import { AUCTION_KIND_PROVIDER, AUCTION_KIND_VICKREY } from '@cerc-io/registry-sdk';
|
|
|
|
import {
|
|
CHAIN_ID,
|
|
TOKEN_TYPE,
|
|
AUCTION_COMMIT_DURATION,
|
|
AUCTION_REVEAL_DURATION,
|
|
delay,
|
|
checkResultAndRetrieveOutput,
|
|
createBond,
|
|
getBondObj,
|
|
getAccountObj,
|
|
getRecordObj,
|
|
getAuthorityObj,
|
|
getAuctionObj,
|
|
getBidObj,
|
|
updateGasAndFeesConfig,
|
|
AUCTION_STATUS,
|
|
getFeesConfig
|
|
} 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('1000000000000000000000000000000');
|
|
|
|
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.latestBlockHeight)).toBeGreaterThan(0);
|
|
expect(outputObj).toHaveProperty('validator');
|
|
expect(outputObj).toHaveProperty('validators');
|
|
expect(outputObj).toHaveProperty('numPeers');
|
|
expect(outputObj).toHaveProperty('peers');
|
|
expect(outputObj).toHaveProperty('diskUsage');
|
|
});
|
|
|
|
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.tx.code).toEqual(0);
|
|
expect(outputObj.tx.amount).toEqual(`${sendAmount}${TOKEN_TYPE}`);
|
|
expect(outputObj.tx.sender).toEqual(testAccount);
|
|
expect(outputObj.tx.recipient).toEqual(testAccount2);
|
|
expect(outputObj.accounts.length).toEqual(2);
|
|
expect(outputObj.accounts).toMatchObject(expectedAccounts);
|
|
});
|
|
|
|
test('laconic registry tokens gettx --hash <hash>', async () => {
|
|
const sendAmount = 1000000000;
|
|
|
|
const sendResult = spawnSync('laconic', ['registry', 'tokens', 'send', '--address', testAccount2, '--type', TOKEN_TYPE, '--quantity', sendAmount.toString()]);
|
|
const sendOutput = checkResultAndRetrieveOutput(sendResult);
|
|
expect(sendOutput.tx.code).toEqual(0);
|
|
|
|
const gettxResult = spawnSync('laconic', ['registry', 'tokens', 'gettx', '--hash', sendOutput.tx.hash]);
|
|
const gettxOutput = checkResultAndRetrieveOutput(gettxResult);
|
|
|
|
expect(gettxOutput.hash).toEqual(sendOutput.tx.hash);
|
|
expect(gettxOutput.code).toEqual(0);
|
|
expect(gettxOutput.amount).toEqual(`${sendAmount}${TOKEN_TYPE}`);
|
|
expect(gettxOutput.sender).toEqual(testAccount);
|
|
expect(gettxOutput.recipient).toEqual(testAccount2);
|
|
});
|
|
});
|
|
|
|
describe('Record operations', () => {
|
|
const gas = 250000;
|
|
const fees = `250000${TOKEN_TYPE}`;
|
|
const bondBalance = 1000000000;
|
|
|
|
test('laconic registry record publish --filename <record_file> --bond-id <bond_id> --gas <gas> --fees <fees>', 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(), '--fees', fees]);
|
|
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('Authority 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}alnt`
|
|
});
|
|
}, (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);
|
|
});
|
|
|
|
test('laconic registry authority list', async () => {
|
|
const result = spawnSync('laconic', ['registry', 'authority', 'list']);
|
|
const authoritiesOutputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected authorities
|
|
const expectedAuthorities = [
|
|
{ name: 'echo.laconic', entry: { ownerAddress: testAccount, status: 'active' } },
|
|
{ name: 'kube.laconic', entry: { ownerAddress: testAccount2, status: 'active' } },
|
|
{ name: 'laconic', entry: { ownerAddress: testAccount, status: 'active' } }
|
|
];
|
|
|
|
// Expected output
|
|
expect(authoritiesOutputObj.length).toEqual(3);
|
|
expect(authoritiesOutputObj).toMatchObject(expectedAuthorities);
|
|
});
|
|
|
|
test('laconic registry authority list --owner <owner_address>', async () => {
|
|
let result = spawnSync('laconic', ['registry', 'authority', 'list', '--owner', testAccount]);
|
|
const authoritiesByOwner1 = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected output
|
|
const expectedAuthoritiesByOwner1 = [
|
|
{ name: 'echo.laconic', entry: { ownerAddress: testAccount, status: 'active' } },
|
|
{ name: 'laconic', entry: { ownerAddress: testAccount, status: 'active' } }
|
|
];
|
|
|
|
expect(authoritiesByOwner1.length).toEqual(2);
|
|
expect(authoritiesByOwner1).toMatchObject(expectedAuthoritiesByOwner1);
|
|
|
|
result = spawnSync('laconic', ['registry', 'authority', 'list', '--owner', testAccount2]);
|
|
const authoritiesByOwner2 = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected output
|
|
const expectedAuthoritiesByOwner2 = [
|
|
{ name: 'kube.laconic', entry: { ownerAddress: testAccount2, status: 'active' } }
|
|
];
|
|
|
|
expect(authoritiesByOwner2.length).toEqual(1);
|
|
expect(authoritiesByOwner2).toMatchObject(expectedAuthoritiesByOwner2);
|
|
});
|
|
});
|
|
|
|
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);
|
|
});
|
|
});
|
|
|
|
describe('Vickrey Auction operations', () => {
|
|
const commitFee = 1000;
|
|
const revealFee = 1000;
|
|
const minimumBid = 100000;
|
|
|
|
const bidAmount = 25000000;
|
|
let bidRevealFilePath: string;
|
|
|
|
test('laconic registry auction create --kind <kind> --commits-duration <commits_duration> --reveals-duration <reveals_duration> --denom <denom> --commit-fee <commit_fee> --reveal-fee <reveal_fee> --minimum-bid <minimum_bid>', async () => {
|
|
const createAuctionResult = spawnSync('laconic', [
|
|
'registry',
|
|
'auction',
|
|
'create',
|
|
'--kind', AUCTION_KIND_VICKREY,
|
|
'--commits-duration', AUCTION_COMMIT_DURATION.toString(),
|
|
'--reveals-duration', AUCTION_REVEAL_DURATION.toString(),
|
|
'--denom', TOKEN_TYPE,
|
|
'--commit-fee', commitFee.toString(),
|
|
'--reveal-fee', revealFee.toString(),
|
|
'--minimum-bid', minimumBid.toString()
|
|
]);
|
|
const outputObj = checkResultAndRetrieveOutput(createAuctionResult);
|
|
|
|
expect(outputObj).toHaveProperty('auctionId');
|
|
|
|
testAuctionId = outputObj.auctionId;
|
|
const getAuctionResult = spawnSync('laconic', ['registry', 'auction', 'get', '--id', testAuctionId]);
|
|
const auctionOutputObj = checkResultAndRetrieveOutput(getAuctionResult);
|
|
|
|
const expectedAuctionObjPartial = {
|
|
kind: AUCTION_KIND_VICKREY,
|
|
status: AUCTION_STATUS.COMMIT,
|
|
ownerAddress: testAccount,
|
|
commitFee: { quantity: commitFee },
|
|
revealFee: { quantity: revealFee },
|
|
minimumBid: { quantity: minimumBid },
|
|
winnerAddresses: [],
|
|
winnerBids: [],
|
|
maxPrice: { quantity: 0 },
|
|
numProviders: 0,
|
|
bids: []
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartial);
|
|
});
|
|
|
|
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);
|
|
|
|
let auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
|
|
let auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
|
|
|
|
const expectedAuctionObjPartial = {
|
|
status: AUCTION_STATUS.REVEAL,
|
|
ownerAddress: testAccount,
|
|
winnerAddresses: [],
|
|
winnerBids: [],
|
|
bids: [{
|
|
bidderAddress: testAccount,
|
|
status: AUCTION_STATUS.COMMIT,
|
|
bidAmount: { quantity: 0 }
|
|
}]
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartial);
|
|
|
|
// 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}${TOKEN_TYPE}`
|
|
});
|
|
|
|
// Get auction with revealed bid
|
|
auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
|
|
auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
|
|
|
|
const expectedAuctionObjPartialOnBidReveal = {
|
|
status: AUCTION_STATUS.REVEAL,
|
|
winnerAddresses: [],
|
|
bids: [{
|
|
bidderAddress: testAccount,
|
|
status: AUCTION_STATUS.REVEAL,
|
|
bidAmount: { quantity: bidAmount }
|
|
}]
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartialOnBidReveal);
|
|
}, (AUCTION_COMMIT_DURATION + 5) * 1000);
|
|
|
|
test('laconic registry auction get <auction_id>', async () => {
|
|
// Wait for auction reveals duration (60s)
|
|
await delay(AUCTION_REVEAL_DURATION * 1000);
|
|
|
|
const auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
|
|
const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
|
|
|
|
const expectedAuctionObjPartial = {
|
|
status: AUCTION_STATUS.COMPLETED,
|
|
ownerAddress: testAccount,
|
|
winnerAddresses: [testAccount],
|
|
winnerBids: [{ quantity: bidAmount }],
|
|
winnerPrice: { quantity: bidAmount }
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartial);
|
|
}, (AUCTION_COMMIT_DURATION + 5) * 1000);
|
|
});
|
|
|
|
describe('Provider Auction operations', () => {
|
|
const txFees = getFeesConfig();
|
|
|
|
const commitFee = 1000;
|
|
const revealFee = 1000;
|
|
const maxPrice = 1000000;
|
|
const numProviders = 2;
|
|
const bidderInitialBlanace = 1000000000;
|
|
testAuctionId = '5e9dd5501e965f25db4fa62635d0ce5f6c59d73ab1a2ea999f8c5bf2f6fb6350';
|
|
|
|
const bidderAccounts = [
|
|
{
|
|
privateKey: 'f40f8e2c9ba70595b6d1cf3bcc47ba539e7d6ad2bcdb16e26c1e369378fd5a55',
|
|
address: 'laconic13cd6ntlcf5y0zmafg6wf96y6vsnq46xagpmjtc',
|
|
bidAmount: 25000
|
|
},
|
|
{
|
|
privateKey: '2c70e81c285e12f196837911aa258b11dff7e4189fc0f11e28cb228956807881',
|
|
address: 'laconic15x7sw49w3x2pahjlr48hunp5gpr7hm54eg3f8h',
|
|
bidAmount: 25300
|
|
},
|
|
{
|
|
privateKey: '1d3a47900e1a5980b171419ac700e779330bc0f85389a4113ff608ca314e25bb',
|
|
address: 'laconic1lkgay8ejvcwmngj3jua2ancdxxkukecz7hty89',
|
|
bidAmount: 25200
|
|
}
|
|
];
|
|
const winnerAccounts = [bidderAccounts[0], bidderAccounts[2]];
|
|
const winnerPrice = bidderAccounts[2].bidAmount;
|
|
|
|
const bidRevealFilePaths: string[] = [];
|
|
|
|
beforeAll(() => {
|
|
// Fund all bidder accounts
|
|
bidderAccounts.forEach(account => {
|
|
spawnSync('laconic', ['registry', 'tokens', 'send', '--address', account.address, '--type', TOKEN_TYPE, '--quantity', bidderInitialBlanace.toString()]);
|
|
});
|
|
});
|
|
|
|
test('laconic registry auction create --kind <kind> --commits-duration <commits_duration> --reveals-duration <reveals_duration> --denom <denom> --commit-fee <commit_fee> --reveal-fee <reveal_fee> --max-price <max_price> --num-providers <num_providers>', async () => {
|
|
const createAuctionResult = spawnSync('laconic', [
|
|
'registry',
|
|
'auction',
|
|
'create',
|
|
'--kind', AUCTION_KIND_PROVIDER,
|
|
'--commits-duration', AUCTION_COMMIT_DURATION.toString(),
|
|
'--reveals-duration', AUCTION_REVEAL_DURATION.toString(),
|
|
'--denom', TOKEN_TYPE,
|
|
'--commit-fee', commitFee.toString(),
|
|
'--reveal-fee', revealFee.toString(),
|
|
'--max-price', maxPrice.toString(),
|
|
'--num-providers', numProviders.toString()
|
|
]);
|
|
|
|
const outputObj = checkResultAndRetrieveOutput(createAuctionResult);
|
|
|
|
expect(outputObj).toHaveProperty('auctionId');
|
|
|
|
testAuctionId = outputObj.auctionId;
|
|
const getAuctionResult = spawnSync('laconic', ['registry', 'auction', 'get', '--id', testAuctionId]);
|
|
const auctionOutputObj = checkResultAndRetrieveOutput(getAuctionResult);
|
|
|
|
const expectedAuctionObjPartial = {
|
|
kind: AUCTION_KIND_PROVIDER,
|
|
status: AUCTION_STATUS.COMMIT,
|
|
ownerAddress: testAccount,
|
|
commitFee: { quantity: commitFee },
|
|
revealFee: { quantity: revealFee },
|
|
minimumBid: { quantity: 0 },
|
|
winnerAddresses: [],
|
|
winnerBids: [],
|
|
maxPrice: { quantity: maxPrice },
|
|
numProviders: numProviders,
|
|
bids: []
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartial);
|
|
});
|
|
|
|
test('laconic registry auction bid commit <auction_id> <quantity> <type>', async () => {
|
|
for (const bidderAccount of bidderAccounts) {
|
|
const result = spawnSync('laconic', ['registry', 'auction', 'bid', 'commit', testAuctionId, bidderAccount.bidAmount.toString(), TOKEN_TYPE, '--txKey', bidderAccount.privateKey]);
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected output
|
|
expect(outputObj.reveal_file).toBeDefined();
|
|
|
|
bidRevealFilePaths.push(outputObj.reveal_file);
|
|
}
|
|
|
|
const auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
|
|
const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
|
|
|
|
const expectedBids = bidderAccounts.map(account => ({
|
|
bidderAddress: account.address,
|
|
status: AUCTION_STATUS.COMMIT,
|
|
bidAmount: { quantity: 0 }
|
|
}));
|
|
const expectedAuctionObjPartial = {
|
|
status: AUCTION_STATUS.COMMIT,
|
|
ownerAddress: testAccount,
|
|
winnerAddresses: [],
|
|
winnerBids: [],
|
|
bids: expectedBids
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartial);
|
|
});
|
|
|
|
test('laconic registry auction bid reveal <auction_id> <file_path>', async () => {
|
|
// Wait for auction commits duration (60s)
|
|
await delay(AUCTION_COMMIT_DURATION * 1000);
|
|
|
|
// Reveal bid
|
|
for (let i = 0; i < bidderAccounts.length; i++) {
|
|
const result = spawnSync('laconic', ['registry', 'auction', 'bid', 'reveal', testAuctionId, bidRevealFilePaths[i], '--txKey', bidderAccounts[i].privateKey]);
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected output
|
|
expect(outputObj).toEqual({ success: true });
|
|
|
|
const revealObject = JSON.parse(fs.readFileSync(bidRevealFilePaths[i], 'utf8'));
|
|
expect(revealObject).toMatchObject({
|
|
chainId: CHAIN_ID,
|
|
auctionId: testAuctionId,
|
|
bidderAddress: bidderAccounts[i].address,
|
|
bidAmount: `${bidderAccounts[i].bidAmount}${TOKEN_TYPE}`
|
|
});
|
|
}
|
|
|
|
// Get auction with revealed bid
|
|
const auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
|
|
const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
|
|
|
|
const expectedBids = bidderAccounts.map(account => ({
|
|
bidderAddress: account.address,
|
|
status: AUCTION_STATUS.REVEAL,
|
|
bidAmount: { quantity: account.bidAmount }
|
|
}));
|
|
const expectedAuctionObjPartialOnBidReveal = {
|
|
status: AUCTION_STATUS.REVEAL,
|
|
winnerAddresses: [],
|
|
bids: expectedBids
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartialOnBidReveal);
|
|
}, (AUCTION_COMMIT_DURATION + 60) * 1000);
|
|
|
|
test('laconic registry auction get <auction_id>', async () => {
|
|
// Wait for auction reveals duration (60s)
|
|
await delay(AUCTION_REVEAL_DURATION * 1000);
|
|
|
|
const auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
|
|
const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
|
|
|
|
const expectedWinnerAddresses = winnerAccounts.map(account => account.address);
|
|
const expectedWinnerBids = winnerAccounts.map(account => ({ quantity: account.bidAmount }));
|
|
|
|
const expectedAuctionObjPartial = {
|
|
status: AUCTION_STATUS.COMPLETED,
|
|
ownerAddress: testAccount,
|
|
winnerAddresses: expectedWinnerAddresses,
|
|
winnerBids: expectedWinnerBids,
|
|
winnerPrice: { quantity: winnerPrice },
|
|
fundsReleased: false
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartial);
|
|
}, (AUCTION_REVEAL_DURATION + 5) * 1000);
|
|
|
|
test('laconic registry auction release-funds <auction_id>', async () => {
|
|
const result = spawnSync('laconic', ['registry', 'auction', 'release-funds', testAuctionId]);
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
expect(outputObj).toEqual({ success: true });
|
|
|
|
const auctionResult = spawnSync('laconic', ['registry', 'auction', 'get', testAuctionId]);
|
|
const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
|
|
|
|
const expectedAuctionObjPartial = {
|
|
status: AUCTION_STATUS.COMPLETED,
|
|
ownerAddress: testAccount,
|
|
fundsReleased: true
|
|
};
|
|
expect(auctionOutputObj[0]).toMatchObject(expectedAuctionObjPartial);
|
|
|
|
const expectedBalances = [
|
|
bidderInitialBlanace - (commitFee) - (2 * txFees) + winnerPrice,
|
|
bidderInitialBlanace - (commitFee) - (2 * txFees),
|
|
bidderInitialBlanace - (commitFee) - (2 * txFees) + winnerPrice
|
|
];
|
|
|
|
for (let i = 0; i < bidderAccounts.length; i++) {
|
|
const result = spawnSync('laconic', ['registry', 'account', 'get', '--address', bidderAccounts[i].address]);
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected account
|
|
const expectedAccount = getAccountObj({ address: bidderAccounts[i].address, balance: expectedBalances[i] });
|
|
|
|
expect(outputObj.length).toEqual(1);
|
|
expect(outputObj[0]).toMatchObject(expectedAccount);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('Gas and fees config', () => {
|
|
const bondAmount = 1000;
|
|
|
|
test('gas set, fees set to Xalnt', async () => {
|
|
// gasPrice not set
|
|
const result = spawnSync('laconic', ['registry', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondAmount.toString()]);
|
|
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
expect(outputObj.bondId).toBeDefined();
|
|
|
|
// gasPrice set (lower than min gas price)
|
|
updateGasAndFeesConfig(undefined, undefined, '0.00001alnt');
|
|
const result1 = spawnSync('laconic', ['registry', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondAmount.toString()]);
|
|
|
|
const outputObj1 = checkResultAndRetrieveOutput(result1);
|
|
expect(outputObj1.bondId).toBeDefined();
|
|
});
|
|
|
|
test('gas not set, fees not set, gasPrice set', async () => {
|
|
updateGasAndFeesConfig(null, null, '1alnt');
|
|
const result = spawnSync('laconic', ['registry', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondAmount.toString()]);
|
|
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
expect(outputObj.bondId).toBeDefined();
|
|
});
|
|
|
|
test('gas not set, fees set without token suffix, gasPrice set', async () => {
|
|
updateGasAndFeesConfig(null, '1.8', '1alnt');
|
|
const result = spawnSync('laconic', ['registry', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondAmount.toString()]);
|
|
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
expect(outputObj.bondId).toBeDefined();
|
|
});
|
|
|
|
test('gas not set, fees not set, gasPrice not set', async () => {
|
|
updateGasAndFeesConfig(null, null, null);
|
|
const result = spawnSync('laconic', ['registry', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondAmount.toString()]);
|
|
|
|
expect(result.status).toBe(1);
|
|
|
|
const output = result.stdout.toString().trim();
|
|
const errorOutput = result.stderr.toString().trim();
|
|
|
|
expect(output).toBe('');
|
|
expect(errorOutput).toContain('Gas price must be set in the client options when auto gas is used.');
|
|
});
|
|
});
|
|
});
|
|
});
|