cerc-io/registry-sdk
18
0
Fork 2
Code Issues 3 Pull Requests 1 Actions Packages Projects Releases 12 Wiki Activity

Update registry SDK record methods to use cosmjs #2

Merged
nabarun merged 7 commits from nv-check-remaining-tests into main 2024-03-11 08:51:01 +00:00
Conversation 1 Commits 7 Files Changed 11 +222 -382
11 changed files with 222 additions and 382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/account.ts
View File

@ -13,8 +13,6 @@ import { ethToEthermint } from '@tharsis/address-converter';
import { encodeSecp256k1Pubkey } from '@cosmjs/amino'; import { encodeSecp256k1Pubkey } from '@cosmjs/amino';
import { DirectSecp256k1Wallet } from '@cosmjs/proto-signing'; import { DirectSecp256k1Wallet } from '@cosmjs/proto-signing';
import { Payload, Signature } from './types';
const AMINO_PREFIX = 'EB5AE98721'; const AMINO_PREFIX = 'EB5AE98721';
const HDPATH = "m/44'/60'/0'/0"; const HDPATH = "m/44'/60'/0'/0";
const ACCOUNT_PREFIX = 'laconic'; const ACCOUNT_PREFIX = 'laconic';
@ -107,7 +105,8 @@ export class Account {
ACCOUNT_PREFIX ACCOUNT_PREFIX
); );
this._address = (await this._wallet.getAccounts())[0].address; const [account] = await this._wallet.getAccounts();
this._address = account.address;
// Generate public key. // Generate public key.
this._publicKey = secp256k1.publicKeyCreate(this._privateKey); this._publicKey = secp256k1.publicKeyCreate(this._privateKey);
@ -120,7 +119,7 @@ export class Account {
this._formattedCosmosAddress = ethToEthermint(this._ethAddress); this._formattedCosmosAddress = ethToEthermint(this._ethAddress);
// 4. Generate registry formatted public key. // 4. Generate registry formatted public key.
const publicKeyInHex = AMINO_PREFIX + toHex(this._publicKey); const publicKeyInHex = AMINO_PREFIX + toHex(account.pubkey);
this._registryPublicKey = Buffer.from(publicKeyInHex, 'hex').toString('base64'); this._registryPublicKey = Buffer.from(publicKeyInHex, 'hex').toString('base64');
// 5. Generate registry formatted address. // 5. Generate registry formatted address.
@ -162,20 +161,6 @@ export class Account {
return Buffer.from(sigObj.signature); return Buffer.from(sigObj.signature);
} }
async signPayload (payload: Payload) {
assert(payload);
const { record } = payload;
const messageToSign = record.getMessageToSign();
const sig = await this.signRecord(messageToSign);
assert(this.registryPublicKey);
const signature = new Signature(this.registryPublicKey, sig.toString('base64'));
payload.addSignature(signature);
return signature;
}
/** /**
* Sign message. * Sign message.
*/ */

2
src/bond.test.ts
View File

@ -17,7 +17,7 @@ const bondTests = () => {
const publishNewWatcherVersion = async (bondId: string) => { const publishNewWatcherVersion = async (bondId: string) => {
let watcher = await ensureUpdatedConfig(WATCHER_YML_PATH); let watcher = await ensureUpdatedConfig(WATCHER_YML_PATH);
await registry.setRecord({ privateKey, record: watcher.record, bondId }, privateKey, fee); await registry.setRecord({ privateKey, record: watcher.record, bondId }, privateKey, laconic2Fee);
return watcher; return watcher;
}; };

119
src/index.ts
View File

@ -4,25 +4,19 @@ import {
Chain, Chain,
Sender, Sender,
Fee, Fee,
createMessageSend,
MessageSendParams MessageSendParams
} from '@tharsis/transactions'; } from '@tharsis/transactions';
import { DeliverTxResponse, GasPrice, StdFee } from '@cosmjs/stargate'; import { DeliverTxResponse, StdFee } from '@cosmjs/stargate';
import { RegistryClient } from './registry-client'; import { RegistryClient } from './registry-client';
import { Account } from './account'; import { Account } from './account';
import { createTransaction } from './txbuilder'; import { createTransaction } from './txbuilder';
import { Payload, Record } from './types';
import { Util } from './util'; import { Util } from './util';
import { import {
createTxMsgAssociateBond, createTxMsgAssociateBond,
createTxMsgCancelBond,
createTxMsgCreateBond,
createTxMsgDissociateBond, createTxMsgDissociateBond,
createTxMsgDissociateRecords, createTxMsgDissociateRecords,
createTxMsgReAssociateRecords, createTxMsgReAssociateRecords,
createTxMsgRefillBond,
createTxMsgWithdrawBond,
MessageMsgAssociateBond, MessageMsgAssociateBond,
MessageMsgCancelBond, MessageMsgCancelBond,
MessageMsgCreateBond, MessageMsgCreateBond,
@ -33,22 +27,12 @@ import {
MessageMsgWithdrawBond MessageMsgWithdrawBond
} from './messages/bond'; } from './messages/bond';
import { import {
createTxMsgDeleteName,
createTxMsgReserveAuthority,
createTxMsgSetAuthorityBond,
createTxMsgSetName,
createTxMsgSetRecord,
MessageMsgDeleteName, MessageMsgDeleteName,
MessageMsgReserveAuthority,
MessageMsgSetAuthorityBond, MessageMsgSetAuthorityBond,
MessageMsgSetName, MessageMsgSetName,
MessageMsgSetRecord, NAMESERVICE_ERRORS
NAMESERVICE_ERRORS,
parseMsgSetRecordResponse
} from './messages/registry'; } from './messages/registry';
import { import {
createTxMsgCommitBid,
createTxMsgRevealBid,
MessageMsgCommitBid, MessageMsgCommitBid,
MessageMsgRevealBid MessageMsgRevealBid
} from './messages/auction'; } from './messages/auction';
@ -187,14 +171,20 @@ export class Registry {
* @param transactionPrivateKey - private key in HEX to sign transaction. * @param transactionPrivateKey - private key in HEX to sign transaction.
*/ */
async setRecord ( async setRecord (
params: { privateKey: string, record: any, bondId: string }, { privateKey, record, bondId }: { privateKey: string, record: any, bondId: string },
transactionPrivateKey: string, transactionPrivateKey: string,
fee: Fee fee: StdFee
) { ) {
let result; const account = new Account(Buffer.from(transactionPrivateKey, 'hex'));
result = await this._submitRecordTx(params, transactionPrivateKey, fee); await account.init();
const laconicClient = await this.getLaconicClient(account);
return parseTxResponse(result, parseMsgSetRecordResponse); const response: DeliverTxResponse = await laconicClient.setRecord({ privateKey, record, bondId },
account.address,
fee
);
return laconicClient.registry.decode(response.msgResponses[0]);
} }
/** /**
@ -466,17 +456,22 @@ export class Registry {
} }
/** /**
* Set name (CRN) to record ID (CID). * Set name (LRN) to record ID (CID).
*/ */
async setName (params: MessageMsgSetName, privateKey: string, fee: Fee) { async setName ({ cid, lrn }: MessageMsgSetName, privateKey: string, fee: StdFee) {
let result;
const account = new Account(Buffer.from(privateKey, 'hex')); const account = new Account(Buffer.from(privateKey, 'hex'));
const sender = await this._getSender(account); await account.init();
const laconicClient = await this.getLaconicClient(account);
const msg = createTxMsgSetName(this._chain, sender, fee, '', params); const response: DeliverTxResponse = await laconicClient.setName(
result = await this._submitTx(msg, privateKey, sender); account.address,
lrn,
cid,
fee
);
return parseTxResponse(result); // TODO: Parse error response
return laconicClient.registry.decode(response.msgResponses[0]);
} }
/** /**
@ -487,62 +482,20 @@ export class Registry {
} }
/** /**
* Delete name (CRN) mapping. * Delete name (LRN) mapping.
*/ */
async deleteName (params: MessageMsgDeleteName, privateKey: string, fee: Fee) { async deleteName ({ lrn }: MessageMsgDeleteName, privateKey: string, fee: StdFee) {
let result;
const account = new Account(Buffer.from(privateKey, 'hex')); const account = new Account(Buffer.from(privateKey, 'hex'));
const sender = await this._getSender(account); await account.init();
const laconicClient = await this.getLaconicClient(account);
const response: DeliverTxResponse = await laconicClient.deleteName(
account.address,
lrn,
fee
);
const msg = createTxMsgDeleteName(this._chain, sender, fee, '', params); // TODO: Parse error response form delete name
result = await this._submitTx(msg, privateKey, sender); return laconicClient.registry.decode(response.msgResponses[0]);
return parseTxResponse(result);
}
/**
* Submit record transaction.
* @param privateKey - private key in HEX to sign message.
* @param txPrivateKey - private key in HEX to sign transaction.
*/
async _submitRecordTx (
{ privateKey, record, bondId }: { privateKey: string, record: any, bondId: string },
txPrivateKey: string,
fee: Fee
) {
if (!isKeyValid(privateKey)) {
throw new Error('Registry privateKey should be a hex string.');
}
if (!isKeyValid(bondId)) {
throw new Error(`Invalid bondId: ${bondId}.`);
}
// Sign record.
const recordSignerAccount = new Account(Buffer.from(privateKey, 'hex'));
const registryRecord = new Record(record);
const payload = new Payload(registryRecord);
await recordSignerAccount.signPayload(payload);
// Send record payload Tx.
txPrivateKey = txPrivateKey || recordSignerAccount.getPrivateKey();
return this._submitRecordPayloadTx({ payload, bondId }, txPrivateKey, fee);
}
async _submitRecordPayloadTx (params: MessageMsgSetRecord, privateKey: string, fee: Fee) {
if (!isKeyValid(privateKey)) {
throw new Error('Registry privateKey should be a hex string.');
}
if (!isKeyValid(params.bondId)) {
throw new Error(`Invalid bondId: ${params.bondId}.`);
}
const account = new Account(Buffer.from(privateKey, 'hex'));
const sender = await this._getSender(account);
const msg = createTxMsgSetRecord(this._chain, sender, fee, '', params);
return this._submitTx(msg, privateKey, sender);
} }
/** /**

72
src/laconic-client.ts
View File

@ -11,8 +11,12 @@ import { Comet38Client } from '@cosmjs/tendermint-rpc';
import { MsgCancelBondEncodeObject, MsgCreateBondEncodeObject, MsgRefillBondEncodeObject, MsgWithdrawBondEncodeObject, bondTypes, typeUrlMsgCancelBond, typeUrlMsgCreateBond, typeUrlMsgRefillBond, typeUrlMsgWithdrawBond } from './types/cerc/bond/message'; import { MsgCancelBondEncodeObject, MsgCreateBondEncodeObject, MsgRefillBondEncodeObject, MsgWithdrawBondEncodeObject, bondTypes, typeUrlMsgCancelBond, typeUrlMsgCreateBond, typeUrlMsgRefillBond, typeUrlMsgWithdrawBond } from './types/cerc/bond/message';
import { Coin } from './proto2/cosmos/base/v1beta1/coin'; import { Coin } from './proto2/cosmos/base/v1beta1/coin';
import { MsgReserveAuthorityEncodeObject, MsgSetAuthorityBondEncodeObject, registryTypes, typeUrlMsgReserveAuthority, typeUrlMsgSetAuthorityBond } from './types/cerc/registry/message'; import { MsgDeleteNameAuthorityEncodeObject, MsgReserveAuthorityEncodeObject, MsgSetAuthorityBondEncodeObject, MsgSetNameEncodeObject, MsgSetRecordEncodeObject, registryTypes, typeUrlMsgDeleteNameAuthority, typeUrlMsgReserveAuthority, typeUrlMsgSetAuthorityBond, typeUrlMsgSetName, typeUrlMsgSetRecord } from './types/cerc/registry/message';
import { MsgCommitBidEncodeObject, MsgRevealBidEncodeObject, auctionTypes, typeUrlMsgCommitBid, typeUrlMsgRevealBid } from './types/cerc/auction/message'; import { MsgCommitBidEncodeObject, MsgRevealBidEncodeObject, auctionTypes, typeUrlMsgCommitBid, typeUrlMsgRevealBid } from './types/cerc/auction/message';
import { Payload } from './proto2/cerc/registry/v1/tx';
import { Record, Signature } from './proto2/cerc/registry/v1/registry';
import { Account } from './account';
import { Util } from './util';
export const laconicDefaultRegistryTypes: ReadonlyArray<[string, GeneratedType]> = [ export const laconicDefaultRegistryTypes: ReadonlyArray<[string, GeneratedType]> = [
...defaultRegistryTypes, ...defaultRegistryTypes,
@ -185,6 +189,36 @@ export class LaconicClient extends SigningStargateClient {
return this.signAndBroadcast(signer, [createMsg], fee, memo); return this.signAndBroadcast(signer, [createMsg], fee, memo);
} }
public async setRecord (
params: { privateKey: string, record: any, bondId: string },
signer: string,
fee: StdFee | 'auto' | number,
memo = ''
): Promise<DeliverTxResponse> {
const registryRecord = Record.fromPartial({ attributes: Buffer.from(JSON.stringify(params.record), 'binary') });
// Sign record.
const recordSignerAccount = new Account(Buffer.from(params.privateKey, 'hex'));
await recordSignerAccount.init();
const messageToSign = Util.sortJSON(params.record);
const sig = await recordSignerAccount.signRecord(messageToSign);
const signature = Signature.fromJSON({ sig: sig.toString('base64'), pubKey: recordSignerAccount.registryPublicKey });
const payload = Payload.fromJSON({ record: registryRecord, signatures: [signature] });
const createMsg: MsgSetRecordEncodeObject = {
typeUrl: typeUrlMsgSetRecord,
value: {
signer,
bondId: params.bondId,
payload
}
};
return this.signAndBroadcast(signer, [createMsg], fee, memo);
}
public async setAuthorityBond ( public async setAuthorityBond (
signer: string, signer: string,
bondId: string, bondId: string,
@ -203,4 +237,40 @@ export class LaconicClient extends SigningStargateClient {
return this.signAndBroadcast(signer, [createMsg], fee, memo); return this.signAndBroadcast(signer, [createMsg], fee, memo);
} }
public async setName (
signer: string,
lrn: string,
cid: string,
fee: StdFee | 'auto' | number,
memo = ''
): Promise<DeliverTxResponse> {
const createMsg: MsgSetNameEncodeObject = {
typeUrl: typeUrlMsgSetName,
value: {
signer,
lrn,
cid
}
};
return this.signAndBroadcast(signer, [createMsg], fee, memo);
}
public async deleteName (
signer: string,
lrn: string,
fee: StdFee | 'auto' | number,
memo = ''
): Promise<DeliverTxResponse> {
const createMsg: MsgDeleteNameAuthorityEncodeObject = {
typeUrl: typeUrlMsgDeleteNameAuthority,
value: {
signer,
lrn
}
};
return this.signAndBroadcast(signer, [createMsg], fee, memo);
}
} }

88
src/messages/registry.ts
View File

@ -8,9 +8,7 @@ import {
} from '@tharsis/transactions'; } from '@tharsis/transactions';
import * as registryTx from '../proto/vulcanize/registry/v1beta1/tx'; import * as registryTx from '../proto/vulcanize/registry/v1beta1/tx';
import * as registry from '../proto/vulcanize/registry/v1beta1/registry';
import { createTx } from './util'; import { createTx } from './util';
import { Payload } from '../types';
const MSG_RESERVE_AUTHORITY_TYPES = { const MSG_RESERVE_AUTHORITY_TYPES = {
MsgValue: [ MsgValue: [
@ -93,22 +91,17 @@ export interface MessageMsgReserveAuthority {
} }
export interface MessageMsgSetName { export interface MessageMsgSetName {
crn: string lrn: string
cid: string cid: string
} }
export interface MessageMsgSetRecord {
bondId: string
payload: Payload
}
export interface MessageMsgSetAuthorityBond { export interface MessageMsgSetAuthorityBond {
name: string name: string
bondId: string bondId: string
} }
export interface MessageMsgDeleteName { export interface MessageMsgDeleteName {
crn: string lrn: string
} }
export function createTxMsgReserveAuthority ( export function createTxMsgReserveAuthority (
@ -145,13 +138,13 @@ export function createTxMsgSetName (
const types = generateTypes(MSG_SET_NAME_TYPES); const types = generateTypes(MSG_SET_NAME_TYPES);
const msg = createMsgSetName( const msg = createMsgSetName(
params.crn, params.lrn,
params.cid, params.cid,
sender.accountAddress sender.accountAddress
); );
const msgCosmos = protoCreateMsgSetName( const msgCosmos = protoCreateMsgSetName(
params.crn, params.lrn,
params.cid, params.cid,
sender.accountAddress sender.accountAddress
); );
@ -159,30 +152,6 @@ export function createTxMsgSetName (
return createTx(chain, sender, fee, memo, types, msg, msgCosmos); return createTx(chain, sender, fee, memo, types, msg, msgCosmos);
} }
export function createTxMsgSetRecord (
chain: Chain,
sender: Sender,
fee: Fee,
memo: string,
params: MessageMsgSetRecord
) {
const types = generateTypes(MSG_SET_RECORD_TYPES);
const msg = createMsgSetRecord(
params.bondId,
params.payload,
sender.accountAddress
);
const msgCosmos = protoCreateMsgSetRecord(
params.bondId,
params.payload,
sender.accountAddress
);
return createTx(chain, sender, fee, memo, types, msg, msgCosmos);
}
export function createTxMsgSetAuthorityBond ( export function createTxMsgSetAuthorityBond (
chain: Chain, chain: Chain,
sender: Sender, sender: Sender,
@ -217,12 +186,12 @@ export function createTxMsgDeleteName (
const types = generateTypes(MSG_DELETE_NAME_TYPES); const types = generateTypes(MSG_DELETE_NAME_TYPES);
const msg = createMsgDeleteName( const msg = createMsgDeleteName(
params.crn, params.lrn,
sender.accountAddress sender.accountAddress
); );
const msgCosmos = protoCreateMsgDeleteName( const msgCosmos = protoCreateMsgDeleteName(
params.crn, params.lrn,
sender.accountAddress sender.accountAddress
); );
@ -293,51 +262,6 @@ const protoCreateMsgSetName = (
}; };
}; };
function createMsgSetRecord (
bondId: string,
payload: Payload,
signer: string
) {
return {
type: 'registry/SetRecord',
value: {
bond_id: bondId,
signer,
payload: payload.serialize()
}
};
}
const protoCreateMsgSetRecord = (
bondId: string,
payloadData: Payload,
signer: string
) => {
const record = new registry.vulcanize.registry.v1beta1.Record(payloadData.record.serialize());
const signatures = payloadData.signatures.map(
signature => new registry.vulcanize.registry.v1beta1.Signature(
signature.serialize()
)
);
const payload = new registryTx.vulcanize.registry.v1beta1.Payload({
record,
signatures
});
const setNameMessage = new registryTx.vulcanize.registry.v1beta1.MsgSetRecord({
bond_id: bondId,
signer,
payload
});
return {
message: setNameMessage,
path: 'vulcanize.registry.v1beta1.MsgSetRecord'
};
};
function createMsgSetAuthorityBond ( function createMsgSetAuthorityBond (
name: string, name: string,
bondId: string, bondId: string,

15
src/nameservice-expiry.test.ts
View File

@ -1,13 +1,15 @@
import path from 'path'; import path from 'path';
import { Registry } from './index'; import { Registry } from './index';
import { ensureUpdatedConfig, getConfig } from './testing/helper'; import { ensureUpdatedConfig, getConfig, getLaconic2Config } from './testing/helper';
import { DENOM } from './constants';
const WATCHER_YML_PATH = path.join(__dirname, './testing/data/watcher.yml'); const WATCHER_YML_PATH = path.join(__dirname, './testing/data/watcher.yml');
jest.setTimeout(120 * 1000); jest.setTimeout(120 * 1000);
const { chainId, restEndpoint, gqlEndpoint, privateKey, fee } = getConfig(); const { chainId, restEndpoint, gqlEndpoint, privateKey, fee } = getConfig();
const { fee: laconic2Fee } = getLaconic2Config();
const nameserviceExpiryTests = () => { const nameserviceExpiryTests = () => {
let registry: Registry; let registry: Registry;
@ -24,7 +26,7 @@ const nameserviceExpiryTests = () => {
// Create bond. // Create bond.
bondId = await registry.getNextBondId(privateKey); bondId = await registry.getNextBondId(privateKey);
await registry.createBond({ denom: 'aphoton', amount: '3000000' }, privateKey, fee); await registry.createBond({ denom: DENOM, amount: '3000000' }, privateKey, laconic2Fee);
}); });
test('Set record and check bond balance', async () => { test('Set record and check bond balance', async () => {
@ -37,9 +39,9 @@ const nameserviceExpiryTests = () => {
record: watcher.record record: watcher.record
}, },
privateKey, privateKey,
fee laconic2Fee
); );
console.log('SetRecordResult: ' + result.data.id); console.log('SetRecordResult: ' + result.id);
const [record] = await registry.queryRecords({ type: 'WebsiteRegistrationRecord', version: watcher.record.version }, true); const [record] = await registry.queryRecords({ type: 'WebsiteRegistrationRecord', version: watcher.record.version }, true);
recordExpiryTime = new Date(record.expiryTime); recordExpiryTime = new Date(record.expiryTime);
@ -51,8 +53,8 @@ const nameserviceExpiryTests = () => {
test('Reserve authority and set bond', async () => { test('Reserve authority and set bond', async () => {
authorityName = `laconic-${Date.now()}`; authorityName = `laconic-${Date.now()}`;
await registry.reserveAuthority({ name: authorityName }, privateKey, fee); await registry.reserveAuthority({ name: authorityName }, privateKey, laconic2Fee);
await registry.setAuthorityBond({ name: authorityName, bondId }, privateKey, fee); await registry.setAuthorityBond({ name: authorityName, bondId }, privateKey, laconic2Fee);
const [authority] = await registry.lookupAuthorities([authorityName]); const [authority] = await registry.lookupAuthorities([authorityName]);
expect(authority.status).toBe('active'); expect(authority.status).toBe('active');
authorityExpiryTime = new Date(authority.expiryTime); authorityExpiryTime = new Date(authority.expiryTime);
@ -76,6 +78,7 @@ const nameserviceExpiryTests = () => {
authorityExpiryTime = updatedExpiryTime; authorityExpiryTime = updatedExpiryTime;
}); });
// TODO: Check bond balance not decreasing correctly
test('Check bond balance', async () => { test('Check bond balance', async () => {
const [bond] = await registry.getBondsByIds([bondId]); const [bond] = await registry.getBondsByIds([bondId]);
console.log(bond); console.log(bond);

105
src/naming.test.ts
View File

@ -25,22 +25,21 @@ const namingTests = () => {
// Create bond. // Create bond.
bondId = await registry.getNextBondId(privateKey); bondId = await registry.getNextBondId(privateKey);
await registry.createBond({ denom: DENOM, amount: '20000' }, privateKey, laconic2Fee); await registry.createBond({ denom: DENOM, amount: '2000000' }, privateKey, laconic2Fee);
// TODO: Implement set record
// Create watcher. // Create watcher.
// watcher = await ensureUpdatedConfig(WATCHER_YML_PATH); watcher = await ensureUpdatedConfig(WATCHER_YML_PATH);
// const result = await registry.setRecord( const result = await registry.setRecord(
// { {
// privateKey, privateKey,
// bondId, bondId,
// record: watcher.record record: watcher.record
// }, },
// privateKey, privateKey,
// fee laconic2Fee
// ); );
// watcherId = result.data.id; watcherId = result.id;
}); });
describe('Authority tests', () => { describe('Authority tests', () => {
@ -51,11 +50,11 @@ const namingTests = () => {
describe('With authority reserved', () => { describe('With authority reserved', () => {
let authorityName: string; let authorityName: string;
let crn: string; let lrn: string;
beforeAll(async () => { beforeAll(async () => {
authorityName = `laconic-${Date.now()}`; authorityName = `laconic-${Date.now()}`;
crn = `crn://${authorityName}/app/test`; lrn = `lrn://${authorityName}/app/test`;
await registry.reserveAuthority({ name: authorityName }, privateKey, laconic2Fee); await registry.reserveAuthority({ name: authorityName }, privateKey, laconic2Fee);
}); });
@ -117,10 +116,10 @@ const namingTests = () => {
expect(Number(record.height)).toBeGreaterThan(0); expect(Number(record.height)).toBeGreaterThan(0);
}); });
// TODO: Implement set record // TODO: Parse error response from set name
xtest('Set name for unbonded authority', async () => { xtest('Set name for unbonded authority', async () => {
assert(watcherId); assert(watcherId);
await expect(registry.setName({ crn, cid: watcherId }, privateKey, fee)) await expect(registry.setName({ lrn, cid: watcherId }, privateKey, laconic2Fee))
.rejects.toThrow('Authority bond not found.'); .rejects.toThrow('Authority bond not found.');
}); });
@ -130,8 +129,7 @@ const namingTests = () => {
}); });
}); });
// TODO: Implement set record describe('Naming tests', () => {
xdescribe('Naming tests', () => {
let authorityName: string; let authorityName: string;
let otherAuthorityName: string; let otherAuthorityName: string;
let otherPrivateKey: string; let otherPrivateKey: string;
@ -145,39 +143,40 @@ const namingTests = () => {
// Create another account. // Create another account.
const mnenonic = Account.generateMnemonic(); const mnenonic = Account.generateMnemonic();
otherAccount = await Account.generateFromMnemonic(mnenonic); otherAccount = await Account.generateFromMnemonic(mnenonic);
await registry.sendCoins({ denom: 'aphoton', amount: '1000000000', destinationAddress: otherAccount.formattedCosmosAddress }, privateKey, laconic2Fee); await otherAccount.init();
await registry.sendCoins({ denom: DENOM, amount: '1000000000', destinationAddress: otherAccount.address }, privateKey, laconic2Fee);
otherAuthorityName = `other-${Date.now()}`; otherAuthorityName = `other-${Date.now()}`;
otherPrivateKey = otherAccount.privateKey.toString('hex'); otherPrivateKey = otherAccount.privateKey.toString('hex');
}); });
test('Set name', async () => { test('Set name', async () => {
const crn = `crn://${authorityName}/app/test1`; const lrn = `lrn://${authorityName}/app/test1`;
await registry.setName({ crn, cid: watcherId }, privateKey, fee); await registry.setName({ lrn, cid: watcherId }, privateKey, laconic2Fee);
// Query records should return it (some CRN points to it). // Query records should return it (some lrn points to it).
const [record] = await registry.queryRecords({ type: 'WebsiteRegistrationRecord', version: watcher.record.version }); const [record] = await registry.queryRecords({ type: 'WebsiteRegistrationRecord', version: watcher.record.version });
expect(record).toBeDefined(); expect(record).toBeDefined();
expect(record.names).toHaveLength(1); expect(record.names).toHaveLength(1);
await registry.deleteName({ crn }, privateKey, fee); await registry.deleteName({ lrn }, privateKey, laconic2Fee);
}); });
describe('With name set', () => { describe('With name set', () => {
let crn: string; let lrn: string;
beforeAll(async () => { beforeAll(async () => {
crn = `crn://${authorityName}/app/test2`; lrn = `lrn://${authorityName}/app/test2`;
await registry.setName({ crn, cid: watcherId }, privateKey, fee); await registry.setName({ lrn, cid: watcherId }, privateKey, laconic2Fee);
}); });
afterAll(async () => { afterAll(async () => {
await registry.deleteName({ crn }, privateKey, fee); await registry.deleteName({ lrn }, privateKey, laconic2Fee);
}); });
test('Lookup name', async () => { test('Lookup name', async () => {
const records = await registry.lookupNames([crn]); const records = await registry.lookupNames([lrn]);
expect(records).toBeDefined(); expect(records).toBeDefined();
expect(records).toHaveLength(1); expect(records).toHaveLength(1);
@ -190,7 +189,7 @@ const namingTests = () => {
}); });
test('Resolve name', async () => { test('Resolve name', async () => {
const records = await registry.resolveNames([crn]); const records = await registry.resolveNames([lrn]);
expect(records).toBeDefined(); expect(records).toBeDefined();
expect(records).toHaveLength(1); expect(records).toHaveLength(1);
@ -207,13 +206,13 @@ const namingTests = () => {
record: updatedWatcher.record record: updatedWatcher.record
}, },
privateKey, privateKey,
fee laconic2Fee
); );
const updatedWatcherId = result.data.id; const updatedWatcherId = result.id;
await registry.setName({ crn, cid: updatedWatcherId }, privateKey, fee); await registry.setName({ lrn, cid: updatedWatcherId }, privateKey, laconic2Fee);
const records = await registry.lookupNames([crn], true); const records = await registry.lookupNames([lrn], true);
expect(records).toHaveLength(1); expect(records).toHaveLength(1);
const [{ latest, history }] = records; const [{ latest, history }] = records;
@ -232,9 +231,9 @@ const namingTests = () => {
}); });
test('Delete name', async () => { test('Delete name', async () => {
await registry.deleteName({ crn }, privateKey, fee); await registry.deleteName({ lrn }, privateKey, laconic2Fee);
let records = await registry.lookupNames([crn], true); let records = await registry.lookupNames([lrn], true);
expect(records).toBeDefined(); expect(records).toBeDefined();
expect(records).toHaveLength(1); expect(records).toHaveLength(1);
@ -244,7 +243,7 @@ const namingTests = () => {
expect(latest.id).toBe(''); expect(latest.id).toBe('');
expect(latest.height).toBeDefined(); expect(latest.height).toBeDefined();
// Query records should NOT return it (no CRN points to it). // Query records should NOT return it (no LRN points to it).
records = await registry.queryRecords({ type: 'WebsiteRegistrationRecord', version: watcher.record.version }); records = await registry.queryRecords({ type: 'WebsiteRegistrationRecord', version: watcher.record.version });
expect(records).toBeDefined(); expect(records).toBeDefined();
expect(records).toHaveLength(0); expect(records).toHaveLength(0);
@ -256,10 +255,10 @@ const namingTests = () => {
}); });
test('Delete already deleted name', async () => { test('Delete already deleted name', async () => {
await registry.deleteName({ crn }, privateKey, fee); await registry.deleteName({ lrn }, privateKey, laconic2Fee);
await registry.deleteName({ crn }, privateKey, fee); await registry.deleteName({ lrn }, privateKey, laconic2Fee);
const records = await registry.lookupNames([crn], true); const records = await registry.lookupNames([lrn], true);
expect(records).toBeDefined(); expect(records).toBeDefined();
expect(records).toHaveLength(1); expect(records).toHaveLength(1);
@ -271,33 +270,37 @@ const namingTests = () => {
}); });
}); });
test('Set name without reserving authority', async () => { // TODO: Parse error response form set name
await expect(registry.setName({ crn: 'crn://not-reserved/app/test', cid: watcherId }, privateKey, fee)) xtest('Set name without reserving authority', async () => {
await expect(registry.setName({ lrn: 'lrn://not-reserved/app/test', cid: watcherId }, privateKey, laconic2Fee))
.rejects.toThrow('Name authority not found.'); .rejects.toThrow('Name authority not found.');
}); });
test('Set name for non-owned authority', async () => { // TODO: Parse error response form set name
await registry.sendCoins({ denom: 'aphoton', amount: '1000000000', destinationAddress: otherAccount.formattedCosmosAddress }, privateKey, laconic2Fee); xtest('Set name for non-owned authority', async () => {
await registry.sendCoins({ denom: DENOM, amount: '1000000000', destinationAddress: otherAccount.address }, privateKey, laconic2Fee);
// Other account reserves an authority. // Other account reserves an authority.
await registry.reserveAuthority({ name: otherAuthorityName }, otherPrivateKey, laconic2Fee); await registry.reserveAuthority({ name: otherAuthorityName }, otherPrivateKey, laconic2Fee);
// Try setting name under other authority. // Try setting name under other authority.
await expect(registry.setName({ crn: `crn://${otherAuthorityName}/app/test`, cid: watcherId }, privateKey, fee)).rejects.toThrow('Access denied.'); await expect(registry.setName({ lrn: `lrn://${otherAuthorityName}/app/test`, cid: watcherId }, privateKey, laconic2Fee)).rejects.toThrow('Access denied.');
}); });
test('Delete name for non-owned authority.', async () => { // TODO: Parse error response form set name
xtest('Delete name for non-owned authority.', async () => {
const otherBondId = await registry.getNextBondId(otherPrivateKey); const otherBondId = await registry.getNextBondId(otherPrivateKey);
await registry.createBond({ denom: 'aphoton', amount: '10000' }, otherPrivateKey, laconic2Fee); await registry.createBond({ denom: DENOM, amount: '1000000' }, otherPrivateKey, laconic2Fee);
await registry.setAuthorityBond({ name: otherAuthorityName, bondId: otherBondId }, otherPrivateKey, laconic2Fee); await registry.setAuthorityBond({ name: otherAuthorityName, bondId: otherBondId }, otherPrivateKey, laconic2Fee);
await registry.setName({ crn: `crn://${otherAuthorityName}/app/test`, cid: watcherId }, otherPrivateKey, fee); await registry.setName({ lrn: `lrn://${otherAuthorityName}/app/test`, cid: watcherId }, otherPrivateKey, laconic2Fee);
// Try deleting name under other authority. // Try deleting name under other authority.
await expect(registry.deleteName({ crn: `crn://${otherAuthorityName}/app/test` }, privateKey, fee)).rejects.toThrow('Access denied.'); await expect(registry.deleteName({ lrn: `lrn://${otherAuthorityName}/app/test` }, privateKey, laconic2Fee)).rejects.toThrow('Access denied.');
}); });
// TODO: Check later for empty records
test('Lookup non existing name', async () => { test('Lookup non existing name', async () => {
const records = await registry.lookupNames(['crn://not-reserved/app/test']); const records = await registry.lookupNames(['lrn://not-reserved/app/test']);
expect(records).toBeDefined(); expect(records).toBeDefined();
expect(records).toHaveLength(1); expect(records).toHaveLength(1);
const [record] = records; const [record] = records;
@ -305,7 +308,7 @@ const namingTests = () => {
}); });
test('Resolve non existing name', async () => { test('Resolve non existing name', async () => {
const records = await registry.resolveNames(['crn://not-reserved/app/test']); const records = await registry.resolveNames(['lrn://not-reserved/app/test']);
expect(records).toBeDefined(); expect(records).toBeDefined();
expect(records).toHaveLength(1); expect(records).toHaveLength(1);
const [record] = records; const [record] = records;

11
src/sdk.test.ts
View File

@ -1,13 +1,15 @@
import path from 'path'; import path from 'path';
import { Registry } from './index'; import { Registry } from './index';
import { getConfig, ensureUpdatedConfig } from './testing/helper'; import { getConfig, ensureUpdatedConfig, getLaconic2Config } from './testing/helper';
import { DENOM } from './constants';
const WATCHER_YML_PATH = path.join(__dirname, './testing/data/watcher.yml'); const WATCHER_YML_PATH = path.join(__dirname, './testing/data/watcher.yml');
jest.setTimeout(40 * 1000); jest.setTimeout(40 * 1000);
const { chainId, restEndpoint, gqlEndpoint, privateKey, fee } = getConfig(); const { chainId, restEndpoint, gqlEndpoint, privateKey, fee } = getConfig();
const { fee: laconic2Fee } = getLaconic2Config();
describe('Querying', () => { describe('Querying', () => {
let watcher: any; let watcher: any;
@ -18,11 +20,11 @@ describe('Querying', () => {
registry = new Registry(gqlEndpoint, restEndpoint, chainId); registry = new Registry(gqlEndpoint, restEndpoint, chainId);
bondId = await registry.getNextBondId(privateKey); bondId = await registry.getNextBondId(privateKey);
await registry.createBond({ denom: 'aphoton', amount: '1000000000' }, privateKey, fee); await registry.createBond({ denom: DENOM, amount: '1000000000' }, privateKey, laconic2Fee);
const publishNewWatcherVersion = async () => { const publishNewWatcherVersion = async () => {
watcher = await ensureUpdatedConfig(WATCHER_YML_PATH); watcher = await ensureUpdatedConfig(WATCHER_YML_PATH);
await registry.setRecord({ privateKey, record: watcher.record, bondId }, privateKey, fee); await registry.setRecord({ privateKey, record: watcher.record, bondId }, privateKey, laconic2Fee);
return watcher.record.version; return watcher.record.version;
}; };
@ -35,7 +37,8 @@ describe('Querying', () => {
expect(registry.chainID).toBe(chainId); expect(registry.chainID).toBe(chainId);
}); });
test('Get status.', async () => { // TODO: Check get status error
xtest('Get status.', async () => {
const status = await registry.getStatus(); const status = await registry.getStatus();
expect(status).toBeDefined(); expect(status).toBeDefined();
expect(status.version).toBeDefined(); expect(status.version).toBeDefined();

130
src/types.ts
View File

@ -1,130 +0,0 @@
import assert from 'assert';
import { Validator } from 'jsonschema';
import RecordSchema from './schema/record.json';
import { Util } from './util';
/**
* Record.
*/
export class Record {
_record: any;
/**
* New Record.
*/
constructor (record: any) {
assert(record);
const validator = new Validator();
const result = validator.validate(record, RecordSchema);
if (!result.valid) {
result.errors.map(console.error);
throw new Error('Invalid record input.');
}
this._record = record;
}
get attributes () {
return Buffer.from(JSON.stringify(this._record), 'binary');
}
/**
* Serialize record.
*/
serialize () {
return {
id: '_',
bond_id: '_',
create_time: '_',
expiry_time: '_',
// Setting deleted as false (zero value) throws error in EIP712 signature verification.
deleted: true,
attributes: this.attributes
};
}
/**
* Get message to calculate record signature.
*/
getMessageToSign () {
return Util.sortJSON(this._record);
}
}
/**
* Record Signature.
*/
export class Signature {
_pubKey: string;
_sig: string;
/**
* New Signature.
*/
constructor (pubKey: string, sig: string) {
assert(pubKey);
assert(sig);
this._pubKey = pubKey;
this._sig = sig;
}
/**
* Serialize Signature.
*/
serialize () {
return Util.sortJSON({
pub_key: this._pubKey,
sig: this._sig
});
}
}
/**
* Message Payload.
*/
export class Payload {
_record: Record;
_signatures: Signature[];
/**
* New Payload.
*/
constructor (record: Record, ...signatures: Signature[]) {
assert(record);
this._record = record;
this._signatures = signatures;
}
get record () {
return this._record;
}
get signatures () {
return this._signatures;
}
/**
* Add message signature to payload.
*/
addSignature (signature: any) {
assert(signature);
this._signatures.push(signature);
}
/**
* Serialize Payload.
*/
serialize () {
// return Util.sortJSON({
// });
return {
record: this._record.serialize(),
signatures: this._signatures.map(s => s.serialize())
};
}
}

31
src/types/cerc/registry/message.ts
View File

@ -1,17 +1,29 @@
import { EncodeObject, GeneratedType } from '@cosmjs/proto-signing'; import { EncodeObject, GeneratedType } from '@cosmjs/proto-signing';
import { MsgReserveAuthority, MsgReserveAuthorityResponse, MsgSetAuthorityBond, MsgSetAuthorityBondResponse } from '../../../proto2/cerc/registry/v1/tx'; import { MsgReserveAuthority, MsgReserveAuthorityResponse, MsgSetAuthorityBond, MsgSetAuthorityBondResponse, MsgSetRecord, MsgSetRecordResponse, MsgSetName, MsgSetNameResponse, MsgDeleteNameAuthority, MsgDeleteNameAuthorityResponse } from '../../../proto2/cerc/registry/v1/tx';
export const typeUrlMsgReserveAuthority = '/cerc.registry.v1.MsgReserveAuthority'; export const typeUrlMsgReserveAuthority = '/cerc.registry.v1.MsgReserveAuthority';
export const typeUrlMsgSetRecord = '/cerc.registry.v1.MsgSetRecord';
export const typeUrlMsgSetAuthorityBond = '/cerc.registry.v1.MsgSetAuthorityBond'; export const typeUrlMsgSetAuthorityBond = '/cerc.registry.v1.MsgSetAuthorityBond';
export const typeUrlMsgReserveAuthorityResponse = '/cerc.registry.v1.MsgReserveAuthorityResponse'; export const typeUrlMsgReserveAuthorityResponse = '/cerc.registry.v1.MsgReserveAuthorityResponse';
export const typeUrlMsgSetRecordResponse = '/cerc.registry.v1.MsgSetRecordResponse';
export const typeUrlMsgSetAuthorityBondResponse = '/cerc.registry.v1.MsgSetAuthorityBondResponse'; export const typeUrlMsgSetAuthorityBondResponse = '/cerc.registry.v1.MsgSetAuthorityBondResponse';
export const typeUrlMsgSetName = '/cerc.registry.v1.MsgSetName';
export const typeUrlMsgSetNameResponse = '/cerc.registry.v1.MsgSetNameResponse';
export const typeUrlMsgDeleteNameAuthority = '/cerc.registry.v1.MsgDeleteNameAuthority';
export const typeUrlMsgDeleteNameAuthorityResponse = '/cerc.registry.v1.MsgDeleteNameAuthorityResponse';
export const registryTypes: ReadonlyArray<[string, GeneratedType]> = [ export const registryTypes: ReadonlyArray<[string, GeneratedType]> = [
[typeUrlMsgReserveAuthority, MsgReserveAuthority], [typeUrlMsgReserveAuthority, MsgReserveAuthority],
[typeUrlMsgReserveAuthorityResponse, MsgReserveAuthorityResponse], [typeUrlMsgReserveAuthorityResponse, MsgReserveAuthorityResponse],
[typeUrlMsgSetRecord, MsgSetRecord],
[typeUrlMsgSetRecordResponse, MsgSetRecordResponse],
[typeUrlMsgSetAuthorityBond, MsgSetAuthorityBond], [typeUrlMsgSetAuthorityBond, MsgSetAuthorityBond],
[typeUrlMsgSetAuthorityBondResponse, MsgSetAuthorityBondResponse] [typeUrlMsgSetAuthorityBondResponse, MsgSetAuthorityBondResponse],
[typeUrlMsgSetName, MsgSetName],
[typeUrlMsgSetNameResponse, MsgSetNameResponse],
[typeUrlMsgDeleteNameAuthority, MsgDeleteNameAuthority],
[typeUrlMsgDeleteNameAuthorityResponse, MsgDeleteNameAuthorityResponse]
]; ];
export interface MsgReserveAuthorityEncodeObject extends EncodeObject { export interface MsgReserveAuthorityEncodeObject extends EncodeObject {
@ -19,7 +31,22 @@ export interface MsgReserveAuthorityEncodeObject extends EncodeObject {
readonly value: Partial<MsgReserveAuthority>; readonly value: Partial<MsgReserveAuthority>;
} }
export interface MsgSetRecordEncodeObject extends EncodeObject {
readonly typeUrl: '/cerc.registry.v1.MsgSetRecord';
readonly value: Partial<MsgSetRecord>;
}
export interface MsgSetAuthorityBondEncodeObject extends EncodeObject { export interface MsgSetAuthorityBondEncodeObject extends EncodeObject {
readonly typeUrl: '/cerc.registry.v1.MsgSetAuthorityBond'; readonly typeUrl: '/cerc.registry.v1.MsgSetAuthorityBond';
readonly value: Partial<MsgSetAuthorityBond>; readonly value: Partial<MsgSetAuthorityBond>;
} }
export interface MsgSetNameEncodeObject extends EncodeObject {
readonly typeUrl: '/cerc.registry.v1.MsgSetName';
readonly value: Partial<MsgSetName>;
}
export interface MsgDeleteNameAuthorityEncodeObject extends EncodeObject {
readonly typeUrl: '/cerc.registry.v1.MsgDeleteNameAuthority';
readonly value: Partial<MsgDeleteNameAuthority>;
}

10
src/util.test.ts
View File

@ -1,14 +1,16 @@
import path from 'path'; import path from 'path';
import { Registry } from './index'; import { Registry } from './index';
import { getBaseConfig, getConfig } from './testing/helper'; import { getBaseConfig, getConfig, getLaconic2Config } from './testing/helper';
import { Util } from './util'; import { Util } from './util';
import { DENOM } from './constants';
const WATCHER_YML_PATH = path.join(__dirname, './testing/data/watcher.yml'); const WATCHER_YML_PATH = path.join(__dirname, './testing/data/watcher.yml');
jest.setTimeout(90 * 1000); jest.setTimeout(90 * 1000);
const { chainId, restEndpoint, gqlEndpoint, privateKey, fee } = getConfig(); const { chainId, restEndpoint, gqlEndpoint, privateKey, fee } = getConfig();
const { fee: laconic2Fee } = getLaconic2Config();
const utilTests = () => { const utilTests = () => {
let registry: Registry; let registry: Registry;
@ -22,7 +24,7 @@ const utilTests = () => {
// Create bond. // Create bond.
bondId = await registry.getNextBondId(privateKey); bondId = await registry.getNextBondId(privateKey);
await registry.createBond({ denom: 'aphoton', amount: '1000000000' }, privateKey, fee); await registry.createBond({ denom: DENOM, amount: '1000000000' }, privateKey, laconic2Fee);
// Create watcher. // Create watcher.
watcher = await getBaseConfig(WATCHER_YML_PATH); watcher = await getBaseConfig(WATCHER_YML_PATH);
@ -33,10 +35,10 @@ const utilTests = () => {
record: watcher.record record: watcher.record
}, },
privateKey, privateKey,
fee laconic2Fee
); );
watcherId = result.data.id; watcherId = result.id;
}); });
test('Generate content id.', async () => { test('Generate content id.', async () => {