difftreelog
fix add/extend xcm tests for moonbeam, extend untrusted reserve location
in: master
4 files changed
tests/src/util/playgrounds/unique.dev.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
import {stringToU8a} from '@polkadot/util';
-import {encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';
+import {blake2AsHex, encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';
import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper, AstarHelper} from './unique';
import {ApiPromise, Keyring, WsProvider} from '@polkadot/api';
import * as defs from '../../interfaces/definitions';
@@ -155,6 +155,7 @@
export class DevMoonbeamHelper extends MoonbeamHelper {
account: MoonbeamAccountGroup;
wait: WaitGroup;
+ fastDemocracy: MoonbeamFastDemocracyGroup;
constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {
options.helperBase = options.helperBase ?? DevMoonbeamHelper;
@@ -163,6 +164,7 @@
super(logger, options);
this.account = new MoonbeamAccountGroup(this);
this.wait = new WaitGroup(this);
+ this.fastDemocracy = new MoonbeamFastDemocracyGroup(this);
}
}
@@ -554,6 +556,103 @@
}
}
+class MoonbeamFastDemocracyGroup {
+ helper: DevMoonbeamHelper;
+
+ constructor(helper: DevMoonbeamHelper) {
+ this.helper = helper;
+ }
+
+ async executeProposal(proposalDesciption: string, encodedProposal: string) {
+ const proposalHash = blake2AsHex(encodedProposal);
+
+ const alithAccount = this.helper.account.alithAccount();
+ const baltatharAccount = this.helper.account.baltatharAccount();
+ const dorothyAccount = this.helper.account.dorothyAccount();
+
+ const councilVotingThreshold = 2;
+ const technicalCommitteeThreshold = 2;
+ const fastTrackVotingPeriod = 3;
+ const fastTrackDelayPeriod = 0;
+
+ console.log(`[democracy] executing '${proposalDesciption}' proposal`);
+
+ // >>> Propose external motion through council >>>
+ console.log('\t* Propose external motion through council.......');
+ const externalMotion = this.helper.democracy.externalProposeMajority({Inline: encodedProposal});
+ const encodedMotion = externalMotion?.method.toHex() || '';
+ const motionHash = blake2AsHex(encodedMotion);
+ console.log('\t* Motion hash is %s', motionHash);
+
+ await this.helper.collective.council.propose(
+ baltatharAccount,
+ councilVotingThreshold,
+ externalMotion,
+ externalMotion.encodedLength,
+ );
+
+ const councilProposalIdx = await this.helper.collective.council.proposalCount() - 1;
+ await this.helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);
+ await this.helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);
+
+ await this.helper.collective.council.close(
+ dorothyAccount,
+ motionHash,
+ councilProposalIdx,
+ {
+ refTime: 1_000_000_000,
+ proofSize: 1_000_000,
+ },
+ externalMotion.encodedLength,
+ );
+ console.log('\t* Propose external motion through council.......DONE');
+ // <<< Propose external motion through council <<<
+
+ // >>> Fast track proposal through technical committee >>>
+ console.log('\t* Fast track proposal through technical committee.......');
+ const fastTrack = this.helper.democracy.fastTrack(proposalHash, fastTrackVotingPeriod, fastTrackDelayPeriod);
+ const encodedFastTrack = fastTrack?.method.toHex() || '';
+ const fastTrackHash = blake2AsHex(encodedFastTrack);
+ console.log('\t* FastTrack hash is %s', fastTrackHash);
+
+ await this.helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);
+
+ const techProposalIdx = await this.helper.collective.techCommittee.proposalCount() - 1;
+ await this.helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);
+ await this.helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);
+
+ await this.helper.collective.techCommittee.close(
+ baltatharAccount,
+ fastTrackHash,
+ techProposalIdx,
+ {
+ refTime: 1_000_000_000,
+ proofSize: 1_000_000,
+ },
+ fastTrack.encodedLength,
+ );
+ console.log('\t* Fast track proposal through technical committee.......DONE');
+ // <<< Fast track proposal through technical committee <<<
+
+ const refIndexField = 0;
+ const referendumIndex = await this.helper.wait.eventData<any>(3, 'democracy', 'Started', refIndexField);
+
+ // >>> Referendum voting >>>
+ console.log(`\t* Referendum #${referendumIndex} voting.......`);
+ await this.helper.democracy.referendumVote(dorothyAccount, referendumIndex, {
+ balance: 10_000_000_000_000_000_000n,
+ vote: {aye: true, conviction: 1},
+ });
+ console.log(`\t* Referendum #${referendumIndex} voting.......DONE`);
+ // <<< Referendum voting <<<
+
+ // Wait for the democracy execute
+ await this.helper.wait.newBlocks(5);
+
+ console.log(`[democracy] executing '${proposalDesciption}' proposal.......DONE`);
+ }
+}
+
class WaitGroup {
helper: ChainHelperBase;
@@ -727,7 +826,7 @@
return promise;
}
- async eventOutcome<EventT>(maxBlocksToWait: number, eventSection: string, eventMethod: string) {
+ async eventData<EventT>(maxBlocksToWait: number, eventSection: string, eventMethod: string, fieldIndex: number) {
const eventRecord = await this.event(maxBlocksToWait, eventSection, eventMethod);
if (eventRecord == null) {
@@ -735,9 +834,9 @@
}
const event = eventRecord!.event;
- const outcome = event.data[1] as EventT;
+ const data = event.data[fieldIndex] as EventT;
- return outcome;
+ return data;
}
}
tests/src/util/playgrounds/unique.tsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// SPDX-License-Identifier: Apache-2.034/* eslint-disable @typescript-eslint/no-var-requires */5/* eslint-disable function-call-argument-newline */6/* eslint-disable no-prototype-builtins */78import {ApiPromise, WsProvider, Keyring} from '@polkadot/api';9import {SignerOptions} from '@polkadot/api/types/submittable';10import {ApiInterfaceEvents} from '@polkadot/api/types';11import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm, base58Encode, blake2AsU8a} from '@polkadot/util-crypto';12import {IKeyringPair} from '@polkadot/types/types';13import {hexToU8a} from '@polkadot/util/hex';14import {u8aConcat} from '@polkadot/util/u8a';15import {16 IApiListeners,17 IBlock,18 IEvent,19 IChainProperties,20 ICollectionCreationOptions,21 ICollectionLimits,22 ICollectionPermissions,23 ICrossAccountId,24 ICrossAccountIdLower,25 ILogger,26 INestingPermissions,27 IProperty,28 IStakingInfo,29 ISchedulerOptions,30 ISubstrateBalance,31 IToken,32 ITokenPropertyPermission,33 ITransactionResult,34 IUniqueHelperLog,35 TApiAllowedListeners,36 TEthereumAccount,37 TSigner,38 TSubstrateAccount,39 TNetworks,40 IForeignAssetMetadata,41 AcalaAssetMetadata,42 MoonbeamAssetInfo,43 DemocracyStandardAccountVote,44 IEthCrossAccountId,45} from './types';46import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';47import type {Vec} from '@polkadot/types-codec';48import {FrameSystemEventRecord} from '@polkadot/types/lookup';4950export class CrossAccountId implements ICrossAccountId {51 Substrate?: TSubstrateAccount;52 Ethereum?: TEthereumAccount;5354 constructor(account: ICrossAccountId) {55 if (account.Substrate) this.Substrate = account.Substrate;56 if (account.Ethereum) this.Ethereum = account.Ethereum;57 }5859 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {60 switch (domain) {61 case 'Substrate': return new CrossAccountId({Substrate: account.address});62 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();63 }64 }6566 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {67 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});68 }6970 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {71 return encodeAddress(decodeAddress(address), ss58Format);72 }7374 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {75 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});76 }7778 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {79 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);80 return this;81 }8283 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {84 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));85 }8687 toEthereum(): CrossAccountId {88 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});89 return this;90 }9192 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {93 return evmToAddress(address, ss58Format);94 }9596 toSubstrate(ss58Format?: number): CrossAccountId {97 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});98 return this;99 }100101 toLowerCase(): CrossAccountId {102 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();103 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();104 return this;105 }106}107108const nesting = {109 toChecksumAddress(address: string): string {110 if (typeof address === 'undefined') return '';111112 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);113114 address = address.toLowerCase().replace(/^0x/i,'');115 const addressHash = keccakAsHex(address).replace(/^0x/i,'');116 const checksumAddress = ['0x'];117118 for (let i = 0; i < address.length; i++) {119 // If ith character is 8 to f then make it uppercase120 if (parseInt(addressHash[i], 16) > 7) {121 checksumAddress.push(address[i].toUpperCase());122 } else {123 checksumAddress.push(address[i]);124 }125 }126 return checksumAddress.join('');127 },128 tokenIdToAddress(collectionId: number, tokenId: number) {129 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8,'0')}${tokenId.toString(16).padStart(8,'0')}`);130 },131};132133class UniqueUtil {134 static transactionStatus = {135 NOT_READY: 'NotReady',136 FAIL: 'Fail',137 SUCCESS: 'Success',138 };139140 static chainLogType = {141 EXTRINSIC: 'extrinsic',142 RPC: 'rpc',143 };144145 static getTokenAccount(token: IToken): CrossAccountId {146 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});147 }148149 static getTokenAddress(token: IToken): string {150 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);151 }152153 static getDefaultLogger(): ILogger {154 return {155 log(msg: any, level = 'INFO') {156 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));157 },158 level: {159 ERROR: 'ERROR',160 WARNING: 'WARNING',161 INFO: 'INFO',162 },163 };164 }165166 static vec2str(arr: string[] | number[]) {167 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');168 }169170 static str2vec(string: string) {171 if (typeof string !== 'string') return string;172 return Array.from(string).map(x => x.charCodeAt(0));173 }174175 static fromSeed(seed: string, ss58Format = 42) {176 const keyring = new Keyring({type: 'sr25519', ss58Format});177 return keyring.addFromUri(seed);178 }179180 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {181 if (creationResult.status !== this.transactionStatus.SUCCESS) {182 throw Error('Unable to create collection!');183 }184185 let collectionId = null;186 creationResult.result.events.forEach(({event: {data, method, section}}) => {187 if ((section === 'common') && (method === 'CollectionCreated')) {188 collectionId = parseInt(data[0].toString(), 10);189 }190 });191192 if (collectionId === null) {193 throw Error('No CollectionCreated event was found!');194 }195196 return collectionId;197 }198199 static extractTokensFromCreationResult(creationResult: ITransactionResult): {200 success: boolean,201 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],202 } {203 if (creationResult.status !== this.transactionStatus.SUCCESS) {204 throw Error('Unable to create tokens!');205 }206 let success = false;207 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];208 creationResult.result.events.forEach(({event: {data, method, section}}) => {209 if (method === 'ExtrinsicSuccess') {210 success = true;211 } else if ((section === 'common') && (method === 'ItemCreated')) {212 tokens.push({213 collectionId: parseInt(data[0].toString(), 10),214 tokenId: parseInt(data[1].toString(), 10),215 owner: data[2].toHuman(),216 amount: data[3].toBigInt(),217 });218 }219 });220 return {success, tokens};221 }222223 static extractTokensFromBurnResult(burnResult: ITransactionResult): {224 success: boolean,225 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],226 } {227 if (burnResult.status !== this.transactionStatus.SUCCESS) {228 throw Error('Unable to burn tokens!');229 }230 let success = false;231 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];232 burnResult.result.events.forEach(({event: {data, method, section}}) => {233 if (method === 'ExtrinsicSuccess') {234 success = true;235 } else if ((section === 'common') && (method === 'ItemDestroyed')) {236 tokens.push({237 collectionId: parseInt(data[0].toString(), 10),238 tokenId: parseInt(data[1].toString(), 10),239 owner: data[2].toHuman(),240 amount: data[3].toBigInt(),241 });242 }243 });244 return {success, tokens};245 }246247 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {248 let eventId = null;249 events.forEach(({event: {data, method, section}}) => {250 if ((section === expectedSection) && (method === expectedMethod)) {251 eventId = parseInt(data[0].toString(), 10);252 }253 });254255 if (eventId === null) {256 throw Error(`No ${expectedMethod} event was found!`);257 }258 return eventId === collectionId;259 }260261 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {262 const normalizeAddress = (address: string | ICrossAccountId) => {263 if(typeof address === 'string') return address;264 const obj = {} as any;265 Object.keys(address).forEach(k => {266 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];267 });268 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);269 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();270 return address;271 };272 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;273 events.forEach(({event: {data, method, section}}) => {274 if ((section === 'common') && (method === 'Transfer')) {275 const hData = (data as any).toJSON();276 transfer = {277 collectionId: hData[0],278 tokenId: hData[1],279 from: normalizeAddress(hData[2]),280 to: normalizeAddress(hData[3]),281 amount: BigInt(hData[4]),282 };283 }284 });285 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;286 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);287 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);288 isSuccess = isSuccess && amount === transfer.amount;289 return isSuccess;290 }291292 static bigIntToDecimals(number: bigint, decimals = 18) {293 const numberStr = number.toString();294 const dotPos = numberStr.length - decimals;295296 if (dotPos <= 0) {297 return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;298 } else {299 const intPart = numberStr.substring(0, dotPos);300 const fractPart = numberStr.substring(dotPos);301 return intPart + '.' + fractPart;302 }303 }304}305306class UniqueEventHelper {307 private static extractIndex(index: any): [number, number] | string {308 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];309 return index.toJSON();310 }311312 private static extractSub(data: any, subTypes: any): {[key: string]: any} {313 let obj: any = {};314 let index = 0;315316 if (data.entries) {317 for(const [key, value] of data.entries()) {318 obj[key] = this.extractData(value, subTypes[index]);319 index++;320 }321 } else obj = data.toJSON();322323 return obj;324 }325326 private static toHuman(data: any) {327 return data && data.toHuman ? data.toHuman() : `${data}`;328 }329330 private static extractData(data: any, type: any): any {331 if(!type) return this.toHuman(data);332 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();333 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();334 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);335 return this.toHuman(data);336 }337338 public static extractEvents(events: {event: any, phase: any}[]): IEvent[] {339 const parsedEvents: IEvent[] = [];340341 events.forEach((record) => {342 const {event, phase} = record;343 const types = event.typeDef;344345 const eventData: IEvent = {346 section: event.section.toString(),347 method: event.method.toString(),348 index: this.extractIndex(event.index),349 data: [],350 phase: phase.toJSON(),351 };352353 event.data.forEach((val: any, index: number) => {354 eventData.data.push(this.extractData(val, types[index]));355 });356357 parsedEvents.push(eventData);358 });359360 return parsedEvents;361 }362}363364export class ChainHelperBase {365 helperBase: any;366367 transactionStatus = UniqueUtil.transactionStatus;368 chainLogType = UniqueUtil.chainLogType;369 util: typeof UniqueUtil;370 eventHelper: typeof UniqueEventHelper;371 logger: ILogger;372 api: ApiPromise | null;373 forcedNetwork: TNetworks | null;374 network: TNetworks | null;375 wsEndpoint: string | null;376 chainLog: IUniqueHelperLog[];377 children: ChainHelperBase[];378 address: AddressGroup;379 chain: ChainGroup;380381 constructor(logger?: ILogger, helperBase?: any) {382 this.helperBase = helperBase;383384 this.util = UniqueUtil;385 this.eventHelper = UniqueEventHelper;386 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();387 this.logger = logger;388 this.api = null;389 this.forcedNetwork = null;390 this.network = null;391 this.wsEndpoint = null;392 this.chainLog = [];393 this.children = [];394 this.address = new AddressGroup(this);395 this.chain = new ChainGroup(this);396 }397398 clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {399 Object.setPrototypeOf(helperCls.prototype, this);400 const newHelper = new helperCls(this.logger, options);401402 newHelper.api = this.api;403 newHelper.network = this.network;404 newHelper.forceNetwork = this.forceNetwork;405406 this.children.push(newHelper);407408 return newHelper;409 }410411 getEndpoint(): string {412 if (this.wsEndpoint === null) throw Error('No connection was established');413 return this.wsEndpoint;414 }415416 getApi(): ApiPromise {417 if(this.api === null) throw Error('API not initialized');418 return this.api;419 }420421 async subscribeEvents(expectedEvents: {section: string, names: string[]}[]) {422 const collectedEvents: IEvent[] = [];423 const unsubscribe = await this.getApi().query.system.events((events: Vec<FrameSystemEventRecord>) => {424 const ievents = this.eventHelper.extractEvents(events);425 ievents.forEach((event) => {426 expectedEvents.forEach((e => {427 if (event.section === e.section && e.names.includes(event.method)) {428 collectedEvents.push(event);429 }430 }));431 });432 });433 return {unsubscribe: unsubscribe as any, collectedEvents};434 }435436 clearChainLog(): void {437 this.chainLog = [];438 }439440 forceNetwork(value: TNetworks): void {441 this.forcedNetwork = value;442 }443444 async connect(wsEndpoint: string, listeners?: IApiListeners) {445 if (this.api !== null) throw Error('Already connected');446 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);447 this.wsEndpoint = wsEndpoint;448 this.api = api;449 this.network = network;450 }451452 async disconnect() {453 for (const child of this.children) {454 child.clearApi();455 }456457 if (this.api === null) return;458 await this.api.disconnect();459 this.clearApi();460 }461462 clearApi() {463 this.api = null;464 this.network = null;465 }466467 static async detectNetwork(api: ApiPromise): Promise<TNetworks> {468 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;469 const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];470471 if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;472473 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;474 return 'opal';475 }476477 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {478 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});479 await api.isReady;480481 const network = await this.detectNetwork(api);482483 await api.disconnect();484485 return network;486 }487488 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{489 api: ApiPromise;490 network: TNetworks;491 }> {492 if(typeof network === 'undefined' || network === null) network = 'opal';493 const supportedRPC = {494 opal: {495 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,496 },497 quartz: {498 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,499 },500 unique: {501 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,502 },503 rococo: {},504 westend: {},505 moonbeam: {},506 moonriver: {},507 acala: {},508 karura: {},509 westmint: {},510 };511 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);512 const rpc = supportedRPC[network];513514 // TODO: investigate how to replace rpc in runtime515 // api._rpcCore.addUserInterfaces(rpc);516517 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});518519 await api.isReadyOrError;520521 if (typeof listeners === 'undefined') listeners = {};522 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {523 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;524 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);525 }526527 return {api, network};528 }529530 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {531 const {events, status} = data;532 if (status.isReady) {533 return this.transactionStatus.NOT_READY;534 }535 if (status.isBroadcast) {536 return this.transactionStatus.NOT_READY;537 }538 if (status.isInBlock || status.isFinalized) {539 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');540 if (errors.length > 0) {541 return this.transactionStatus.FAIL;542 }543 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {544 return this.transactionStatus.SUCCESS;545 }546 }547548 return this.transactionStatus.FAIL;549 }550551 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {552 const sign = (callback: any) => {553 if(options !== null) return transaction.signAndSend(sender, options, callback);554 return transaction.signAndSend(sender, callback);555 };556 // eslint-disable-next-line no-async-promise-executor557 return new Promise(async (resolve, reject) => {558 try {559 const unsub = await sign((result: any) => {560 const status = this.getTransactionStatus(result);561562 if (status === this.transactionStatus.SUCCESS) {563 this.logger.log(`${label} successful`);564 unsub();565 resolve({result, status, blockHash: result.status.asInBlock.toHuman()});566 } else if (status === this.transactionStatus.FAIL) {567 let moduleError = null;568569 if (result.hasOwnProperty('dispatchError')) {570 const dispatchError = result['dispatchError'];571572 if (dispatchError) {573 if (dispatchError.isModule) {574 const modErr = dispatchError.asModule;575 const errorMeta = dispatchError.registry.findMetaError(modErr);576577 moduleError = `${errorMeta.section}.${errorMeta.name}`;578 } else {579 moduleError = dispatchError.toHuman();580 }581 } else {582 this.logger.log(result, this.logger.level.ERROR);583 }584 }585586 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);587 unsub();588 reject({status, moduleError, result});589 }590 });591 } catch (e) {592 this.logger.log(e, this.logger.level.ERROR);593 reject(e);594 }595 });596 }597598 async signTransactionWithoutSending(signer: TSigner, tx: any) {599 const api = this.getApi();600 const signingInfo = await api.derive.tx.signingInfo(signer.address);601602 tx.sign(signer, {603 blockHash: api.genesisHash,604 genesisHash: api.genesisHash,605 runtimeVersion: api.runtimeVersion,606 nonce: signingInfo.nonce,607 });608609 return tx.toHex();610 }611612 async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {613 const api = this.getApi();614 const signingInfo = await api.derive.tx.signingInfo(signer.address);615616 // We need to sign the tx because617 // unsigned transactions does not have an inclusion fee618 tx.sign(signer, {619 blockHash: api.genesisHash,620 genesisHash: api.genesisHash,621 runtimeVersion: api.runtimeVersion,622 nonce: signingInfo.nonce,623 });624625 if (len === null) {626 return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;627 } else {628 return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;629 }630 }631632 constructApiCall(apiCall: string, params: any[]) {633 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);634 let call = this.getApi() as any;635 for(const part of apiCall.slice(4).split('.')) {636 call = call[part];637 if (!call) {638 const advice = part.includes('_') ? ' Looks like it needs to be converted to camel case.' : '';639 throw Error(`Function ${part} of api call ${apiCall} not found.${advice}`);640 }641 }642 return call(...params);643 }644645 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {646 if(this.api === null) throw Error('API not initialized');647 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);648649 const startTime = (new Date()).getTime();650 let result: ITransactionResult;651 let events: IEvent[] = [];652 try {653 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;654 events = this.eventHelper.extractEvents(result.result.events);655 const errorEvent = events.find((event) => event.method == 'ExecutedFailed' || event.method == 'CreatedFailed');656 if (errorEvent)657 throw Error(errorEvent.method + ': ' + extrinsic);658 }659 catch(e) {660 if(!(e as object).hasOwnProperty('status')) throw e;661 result = e as ITransactionResult;662 }663664 const endTime = (new Date()).getTime();665666 const log = {667 executedAt: endTime,668 executionTime: endTime - startTime,669 type: this.chainLogType.EXTRINSIC,670 status: result.status,671 call: extrinsic,672 signer: this.getSignerAddress(sender),673 params,674 } as IUniqueHelperLog;675676 let errorMessage = '';677678 if(result.status !== this.transactionStatus.SUCCESS) {679 if (result.moduleError) {680 errorMessage = typeof result.moduleError === 'string'681 ? result.moduleError682 : `${Object.keys(result.moduleError)[0]}: ${Object.values(result.moduleError)[0]}`;683 log.moduleError = errorMessage;684 }685 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;686 }687 if(events.length > 0) log.events = events;688689 this.chainLog.push(log);690691 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {692 if (result.moduleError) throw Error(`${errorMessage}`);693 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));694 }695 return result;696 }697698 async callRpc(rpc: string, params?: any[]) {699 if(typeof params === 'undefined') params = [];700 if(this.api === null) throw Error('API not initialized');701 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);702703 const startTime = (new Date()).getTime();704 let result;705 let error = null;706 const log = {707 type: this.chainLogType.RPC,708 call: rpc,709 params,710 } as IUniqueHelperLog;711712 try {713 result = await this.constructApiCall(rpc, params);714 }715 catch(e) {716 error = e;717 }718719 const endTime = (new Date()).getTime();720721 log.executedAt = endTime;722 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';723 log.executionTime = endTime - startTime;724725 this.chainLog.push(log);726727 if(error !== null) throw error;728729 return result;730 }731732 getSignerAddress(signer: IKeyringPair | string): string {733 if(typeof signer === 'string') return signer;734 return signer.address;735 }736737 fetchAllPalletNames(): string[] {738 if(this.api === null) throw Error('API not initialized');739 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase()).sort();740 }741742 fetchMissingPalletNames(requiredPallets: string[]): string[] {743 const palletNames = this.fetchAllPalletNames();744 return requiredPallets.filter(p => !palletNames.includes(p));745 }746}747748749class HelperGroup<T extends ChainHelperBase> {750 helper: T;751752 constructor(uniqueHelper: T) {753 this.helper = uniqueHelper;754 }755}756757758class CollectionGroup extends HelperGroup<UniqueHelper> {759 /**760 * Get number of blocks when sponsored transaction is available.761 *762 * @param collectionId ID of collection763 * @param tokenId ID of token764 * @param addressObj address for which the sponsorship is checked765 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});766 * @returns number of blocks or null if sponsorship hasn't been set767 */768 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {769 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();770 }771772 /**773 * Get the number of created collections.774 *775 * @returns number of created collections776 */777 async getTotalCount(): Promise<number> {778 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();779 }780781 /**782 * Get information about the collection with additional data,783 * including the number of tokens it contains, its administrators,784 * the normalized address of the collection's owner, and decoded name and description.785 *786 * @param collectionId ID of collection787 * @example await getData(2)788 * @returns collection information object789 */790 async getData(collectionId: number): Promise<{791 id: number;792 name: string;793 description: string;794 tokensCount: number;795 admins: CrossAccountId[];796 normalizedOwner: TSubstrateAccount;797 raw: any798 } | null> {799 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);800 const humanCollection = collection.toHuman(), collectionData = {801 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],802 raw: humanCollection,803 } as any, jsonCollection = collection.toJSON();804 if (humanCollection === null) return null;805 collectionData.raw.limits = jsonCollection.limits;806 collectionData.raw.permissions = jsonCollection.permissions;807 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);808 for (const key of ['name', 'description']) {809 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);810 }811812 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))813 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)814 : 0;815 collectionData.admins = await this.getAdmins(collectionId);816817 return collectionData;818 }819820 /**821 * Get the addresses of the collection's administrators, optionally normalized.822 *823 * @param collectionId ID of collection824 * @param normalize whether to normalize the addresses to the default ss58 format825 * @example await getAdmins(1)826 * @returns array of administrators827 */828 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {829 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();830831 return normalize832 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())833 : admins;834 }835836 /**837 * Get the addresses added to the collection allow-list, optionally normalized.838 * @param collectionId ID of collection839 * @param normalize whether to normalize the addresses to the default ss58 format840 * @example await getAllowList(1)841 * @returns array of allow-listed addresses842 */843 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {844 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();845 return normalize846 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())847 : allowListed;848 }849850 /**851 * Get the effective limits of the collection instead of null for default values852 *853 * @param collectionId ID of collection854 * @example await getEffectiveLimits(2)855 * @returns object of collection limits856 */857 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {858 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();859 }860861 /**862 * Burns the collection if the signer has sufficient permissions and collection is empty.863 *864 * @param signer keyring of signer865 * @param collectionId ID of collection866 * @example await helper.collection.burn(aliceKeyring, 3);867 * @returns ```true``` if extrinsic success, otherwise ```false```868 */869 async burn(signer: TSigner, collectionId: number): Promise<boolean> {870 const result = await this.helper.executeExtrinsic(871 signer,872 'api.tx.unique.destroyCollection', [collectionId],873 true,874 );875876 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');877 }878879 /**880 * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.881 *882 * @param signer keyring of signer883 * @param collectionId ID of collection884 * @param sponsorAddress Sponsor substrate address885 * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")886 * @returns ```true``` if extrinsic success, otherwise ```false```887 */888 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {889 const result = await this.helper.executeExtrinsic(890 signer,891 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],892 true,893 );894895 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorSet');896 }897898 /**899 * Confirms consent to sponsor the collection on behalf of the signer.900 *901 * @param signer keyring of signer902 * @param collectionId ID of collection903 * @example confirmSponsorship(aliceKeyring, 10)904 * @returns ```true``` if extrinsic success, otherwise ```false```905 */906 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {907 const result = await this.helper.executeExtrinsic(908 signer,909 'api.tx.unique.confirmSponsorship', [collectionId],910 true,911 );912913 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'SponsorshipConfirmed');914 }915916 /**917 * Removes the sponsor of a collection, regardless if it consented or not.918 *919 * @param signer keyring of signer920 * @param collectionId ID of collection921 * @example removeSponsor(aliceKeyring, 10)922 * @returns ```true``` if extrinsic success, otherwise ```false```923 */924 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {925 const result = await this.helper.executeExtrinsic(926 signer,927 'api.tx.unique.removeCollectionSponsor', [collectionId],928 true,929 );930931 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorRemoved');932 }933934 /**935 * Sets the limits of the collection. At least one limit must be specified for a correct call.936 *937 * @param signer keyring of signer938 * @param collectionId ID of collection939 * @param limits collection limits object940 * @example941 * await setLimits(942 * aliceKeyring,943 * 10,944 * {945 * sponsorTransferTimeout: 0,946 * ownerCanDestroy: false947 * }948 * )949 * @returns ```true``` if extrinsic success, otherwise ```false```950 */951 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {952 const result = await this.helper.executeExtrinsic(953 signer,954 'api.tx.unique.setCollectionLimits', [collectionId, limits],955 true,956 );957958 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionLimitSet');959 }960961 /**962 * Changes the owner of the collection to the new Substrate address.963 *964 * @param signer keyring of signer965 * @param collectionId ID of collection966 * @param ownerAddress substrate address of new owner967 * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")968 * @returns ```true``` if extrinsic success, otherwise ```false```969 */970 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {971 const result = await this.helper.executeExtrinsic(972 signer,973 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],974 true,975 );976977 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionOwnerChanged');978 }979980 /**981 * Adds a collection administrator.982 *983 * @param signer keyring of signer984 * @param collectionId ID of collection985 * @param adminAddressObj Administrator address (substrate or ethereum)986 * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})987 * @returns ```true``` if extrinsic success, otherwise ```false```988 */989 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {990 const result = await this.helper.executeExtrinsic(991 signer,992 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],993 true,994 );995996 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminAdded');997 }998999 /**1000 * Removes a collection administrator.1001 *1002 * @param signer keyring of signer1003 * @param collectionId ID of collection1004 * @param adminAddressObj Administrator address (substrate or ethereum)1005 * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})1006 * @returns ```true``` if extrinsic success, otherwise ```false```1007 */1008 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {1009 const result = await this.helper.executeExtrinsic(1010 signer,1011 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],1012 true,1013 );10141015 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminRemoved');1016 }10171018 /**1019 * Check if user is in allow list.1020 *1021 * @param collectionId ID of collection1022 * @param user Account to check1023 * @example await getAdmins(1)1024 * @returns is user in allow list1025 */1026 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {1027 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();1028 }10291030 /**1031 * Adds an address to allow list1032 * @param signer keyring of signer1033 * @param collectionId ID of collection1034 * @param addressObj address to add to the allow list1035 * @returns ```true``` if extrinsic success, otherwise ```false```1036 */1037 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1038 const result = await this.helper.executeExtrinsic(1039 signer,1040 'api.tx.unique.addToAllowList', [collectionId, addressObj],1041 true,1042 );10431044 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressAdded');1045 }10461047 /**1048 * Removes an address from allow list1049 *1050 * @param signer keyring of signer1051 * @param collectionId ID of collection1052 * @param addressObj address to remove from the allow list1053 * @returns ```true``` if extrinsic success, otherwise ```false```1054 */1055 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1056 const result = await this.helper.executeExtrinsic(1057 signer,1058 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],1059 true,1060 );10611062 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressRemoved');1063 }10641065 /**1066 * Sets onchain permissions for selected collection.1067 *1068 * @param signer keyring of signer1069 * @param collectionId ID of collection1070 * @param permissions collection permissions object1071 * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});1072 * @returns ```true``` if extrinsic success, otherwise ```false```1073 */1074 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {1075 const result = await this.helper.executeExtrinsic(1076 signer,1077 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],1078 true,1079 );10801081 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPermissionSet');1082 }10831084 /**1085 * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.1086 *1087 * @param signer keyring of signer1088 * @param collectionId ID of collection1089 * @param permissions nesting permissions object1090 * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});1091 * @returns ```true``` if extrinsic success, otherwise ```false```1092 */1093 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1094 return await this.setPermissions(signer, collectionId, {nesting: permissions});1095 }10961097 /**1098 * Disables nesting for selected collection.1099 *1100 * @param signer keyring of signer1101 * @param collectionId ID of collection1102 * @example disableNesting(aliceKeyring, 10);1103 * @returns ```true``` if extrinsic success, otherwise ```false```1104 */1105 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1106 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1107 }11081109 /**1110 * Sets onchain properties to the collection.1111 *1112 * @param signer keyring of signer1113 * @param collectionId ID of collection1114 * @param properties array of property objects1115 * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);1116 * @returns ```true``` if extrinsic success, otherwise ```false```1117 */1118 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1119 const result = await this.helper.executeExtrinsic(1120 signer,1121 'api.tx.unique.setCollectionProperties', [collectionId, properties],1122 true,1123 );11241125 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1126 }11271128 /**1129 * Get collection properties.1130 *1131 * @param collectionId ID of collection1132 * @param propertyKeys optionally filter the returned properties to only these keys1133 * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1134 * @returns array of key-value pairs1135 */1136 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1137 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1138 }11391140 async getPropertiesConsumedSpace(collectionId: number): Promise<number> {1141 const api = this.helper.getApi();1142 const props = (await api.query.common.collectionProperties(collectionId)).toJSON();11431144 return (props! as any).consumedSpace;1145 }11461147 async getCollectionOptions(collectionId: number) {1148 return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1149 }11501151 /**1152 * Deletes onchain properties from the collection.1153 *1154 * @param signer keyring of signer1155 * @param collectionId ID of collection1156 * @param propertyKeys array of property keys to delete1157 * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1158 * @returns ```true``` if extrinsic success, otherwise ```false```1159 */1160 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1161 const result = await this.helper.executeExtrinsic(1162 signer,1163 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1164 true,1165 );11661167 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1168 }11691170 /**1171 * Changes the owner of the token.1172 *1173 * @param signer keyring of signer1174 * @param collectionId ID of collection1175 * @param tokenId ID of token1176 * @param addressObj address of a new owner1177 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1178 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1179 * @returns true if the token success, otherwise false1180 */1181 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1182 const result = await this.helper.executeExtrinsic(1183 signer,1184 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1185 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1186 );11871188 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1189 }11901191 /**1192 *1193 * Change ownership of a token(s) on behalf of the owner.1194 *1195 * @param signer keyring of signer1196 * @param collectionId ID of collection1197 * @param tokenId ID of token1198 * @param fromAddressObj address on behalf of which the token will be sent1199 * @param toAddressObj new token owner1200 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1201 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1202 * @returns true if the token success, otherwise false1203 */1204 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1205 const result = await this.helper.executeExtrinsic(1206 signer,1207 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1208 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1209 );1210 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1211 }12121213 /**1214 *1215 * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1216 *1217 * @param signer keyring of signer1218 * @param collectionId ID of collection1219 * @param tokenId ID of token1220 * @param amount amount of tokens to be burned. For NFT must be set to 1n1221 * @example burnToken(aliceKeyring, 10, 5);1222 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1223 */1224 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1225 const burnResult = await this.helper.executeExtrinsic(1226 signer,1227 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1228 true, // `Unable to burn token for ${label}`,1229 );1230 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1231 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1232 return burnedTokens.success;1233 }12341235 /**1236 * Destroys a concrete instance of NFT on behalf of the owner1237 *1238 * @param signer keyring of signer1239 * @param collectionId ID of collection1240 * @param tokenId ID of token1241 * @param fromAddressObj address on behalf of which the token will be burnt1242 * @param amount amount of tokens to be burned. For NFT must be set to 1n1243 * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1244 * @returns ```true``` if extrinsic success, otherwise ```false```1245 */1246 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1247 const burnResult = await this.helper.executeExtrinsic(1248 signer,1249 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1250 true, // `Unable to burn token from for ${label}`,1251 );1252 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1253 return burnedTokens.success && burnedTokens.tokens.length > 0;1254 }12551256 /**1257 * Set, change, or remove approved address to transfer the ownership of the NFT.1258 *1259 * @param signer keyring of signer1260 * @param collectionId ID of collection1261 * @param tokenId ID of token1262 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1263 * @param amount amount of token to be approved. For NFT must be set to 1n1264 * @returns ```true``` if extrinsic success, otherwise ```false```1265 */1266 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1267 const approveResult = await this.helper.executeExtrinsic(1268 signer,1269 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1270 true, // `Unable to approve token for ${label}`,1271 );12721273 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1274 }12751276 /**1277 * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1278 *1279 * @param signer keyring of signer1280 * @param collectionId ID of collection1281 * @param tokenId ID of token1282 * @param fromAddressObj Signer's Ethereum address containing her tokens1283 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1284 * @param amount amount of token to be approved. For NFT must be set to 1n1285 * @returns ```true``` if extrinsic success, otherwise ```false```1286 */1287 async approveTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1288 const approveResult = await this.helper.executeExtrinsic(1289 signer,1290 'api.tx.unique.approveFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1291 true, // `Unable to approve token for ${label}`,1292 );12931294 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1295 }12961297 /**1298 * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1299 *1300 * @param signer keyring of signer1301 * @param collectionId ID of collection1302 * @param tokenId ID of token1303 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1304 * @param amount amount of token to be approved. For NFT must be set to 1n1305 * @returns ```true``` if extrinsic success, otherwise ```false```1306 */1307 async approveTokenFromEth(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1308 const ethMirror = CrossAccountId.fromKeyring(signer).toEthereum();1309 return await this.approveTokenFrom(signer, collectionId, tokenId, ethMirror, toAddressObj, amount);1310 }13111312 /**1313 * Get the amount of token pieces approved to transfer or burn. Normally 0.1314 *1315 * @param collectionId ID of collection1316 * @param tokenId ID of token1317 * @param toAccountObj address which is approved to use token pieces1318 * @param fromAccountObj address which may have allowed the use of its owned tokens1319 * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1320 * @returns number of approved to transfer pieces1321 */1322 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1323 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1324 }13251326 /**1327 * Get the last created token ID in a collection1328 *1329 * @param collectionId ID of collection1330 * @example getLastTokenId(10);1331 * @returns id of the last created token1332 */1333 async getLastTokenId(collectionId: number): Promise<number> {1334 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1335 }13361337 /**1338 * Check if token exists1339 *1340 * @param collectionId ID of collection1341 * @param tokenId ID of token1342 * @example doesTokenExist(10, 20);1343 * @returns true if the token exists, otherwise false1344 */1345 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1346 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1347 }1348}13491350class NFTnRFT extends CollectionGroup {1351 /**1352 * Get tokens owned by account1353 *1354 * @param collectionId ID of collection1355 * @param addressObj tokens owner1356 * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1357 * @returns array of token ids owned by account1358 */1359 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1360 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1361 }13621363 /**1364 * Get token data1365 *1366 * @param collectionId ID of collection1367 * @param tokenId ID of token1368 * @param propertyKeys optionally filter the token properties to only these keys1369 * @param blockHashAt optionally query the data at some block with this hash1370 * @example getToken(10, 5);1371 * @returns human readable token data1372 */1373 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1374 properties: IProperty[];1375 owner: CrossAccountId;1376 normalizedOwner: CrossAccountId;1377 }| null> {1378 let tokenData;1379 if(typeof blockHashAt === 'undefined') {1380 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1381 }1382 else {1383 if(propertyKeys.length == 0) {1384 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1385 if(!collection) return null;1386 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1387 }1388 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1389 }1390 tokenData = tokenData.toHuman();1391 if (tokenData === null || tokenData.owner === null) return null;1392 const owner = {} as any;1393 for (const key of Object.keys(tokenData.owner)) {1394 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'1395 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])1396 : tokenData.owner[key];1397 }1398 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1399 return tokenData;1400 }14011402 /**1403 * Get token's owner1404 * @param collectionId ID of collection1405 * @param tokenId ID of token1406 * @param blockHashAt optionally query the data at the block with this hash1407 * @example getTokenOwner(10, 5);1408 * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1409 */1410 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1411 let owner;1412 if (typeof blockHashAt === 'undefined') {1413 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1414 } else {1415 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1416 }1417 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1418 }14191420 /**1421 * Recursively find the address that owns the token1422 * @param collectionId ID of collection1423 * @param tokenId ID of token1424 * @param blockHashAt1425 * @example getTokenTopmostOwner(10, 5);1426 * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1427 */1428 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1429 let owner;1430 if (typeof blockHashAt === 'undefined') {1431 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1432 } else {1433 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1434 }14351436 if (owner === null) return null;14371438 return owner.toHuman();1439 }14401441 /**1442 * Nest one token into another1443 * @param signer keyring of signer1444 * @param tokenObj token to be nested1445 * @param rootTokenObj token to be parent1446 * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1447 * @returns ```true``` if extrinsic success, otherwise ```false```1448 */1449 async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1450 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1451 const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1452 if(!result) {1453 throw Error('Unable to nest token!');1454 }1455 return result;1456 }14571458 /**1459 * Remove token from nested state1460 * @param signer keyring of signer1461 * @param tokenObj token to unnest1462 * @param rootTokenObj parent of a token1463 * @param toAddressObj address of a new token owner1464 * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1465 * @returns ```true``` if extrinsic success, otherwise ```false```1466 */1467 async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1468 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1469 const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1470 if(!result) {1471 throw Error('Unable to unnest token!');1472 }1473 return result;1474 }14751476 /**1477 * Set permissions to change token properties1478 *1479 * @param signer keyring of signer1480 * @param collectionId ID of collection1481 * @param permissions permissions to change a property by the collection admin or token owner1482 * @example setTokenPropertyPermissions(1483 * aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1484 * )1485 * @returns true if extrinsic success otherwise false1486 */1487 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1488 const result = await this.helper.executeExtrinsic(1489 signer,1490 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1491 true,1492 );14931494 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1495 }14961497 /**1498 * Get token property permissions.1499 *1500 * @param collectionId ID of collection1501 * @param propertyKeys optionally filter the returned property permissions to only these keys1502 * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1503 * @returns array of key-permission pairs1504 */1505 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1506 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1507 }15081509 /**1510 * Set token properties1511 *1512 * @param signer keyring of signer1513 * @param collectionId ID of collection1514 * @param tokenId ID of token1515 * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1516 * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1517 * @returns ```true``` if extrinsic success, otherwise ```false```1518 */1519 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1520 const result = await this.helper.executeExtrinsic(1521 signer,1522 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1523 true,1524 );15251526 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1527 }15281529 /**1530 * Get properties, metadata assigned to a token.1531 *1532 * @param collectionId ID of collection1533 * @param tokenId ID of token1534 * @param propertyKeys optionally filter the returned properties to only these keys1535 * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1536 * @returns array of key-value pairs1537 */1538 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1539 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1540 }15411542 /**1543 * Delete the provided properties of a token1544 * @param signer keyring of signer1545 * @param collectionId ID of collection1546 * @param tokenId ID of token1547 * @param propertyKeys property keys to be deleted1548 * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1549 * @returns ```true``` if extrinsic success, otherwise ```false```1550 */1551 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1552 const result = await this.helper.executeExtrinsic(1553 signer,1554 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1555 true,1556 );15571558 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1559 }15601561 /**1562 * Mint new collection1563 *1564 * @param signer keyring of signer1565 * @param collectionOptions basic collection options and properties1566 * @param mode NFT or RFT type of a collection1567 * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1568 * @returns object of the created collection1569 */1570 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1571 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1572 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1573 for (const key of ['name', 'description', 'tokenPrefix']) {1574 if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);1575 }1576 const creationResult = await this.helper.executeExtrinsic(1577 signer,1578 'api.tx.unique.createCollectionEx', [collectionOptions],1579 true, // errorLabel,1580 );1581 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1582 }15831584 getCollectionObject(_collectionId: number): any {1585 return null;1586 }15871588 getTokenObject(_collectionId: number, _tokenId: number): any {1589 return null;1590 }15911592 /**1593 * Tells whether the given `owner` approves the `operator`.1594 * @param collectionId ID of collection1595 * @param owner owner address1596 * @param operator operator addrees1597 * @returns true if operator is enabled1598 */1599 async allowanceForAll(collectionId: number, owner: ICrossAccountId, operator: ICrossAccountId): Promise<boolean> {1600 return (await this.helper.callRpc('api.rpc.unique.allowanceForAll', [collectionId, owner, operator])).toJSON();1601 }16021603 /** Sets or unsets the approval of a given operator.1604 * The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1605 * @param operator Operator1606 * @param approved Should operator status be granted or revoked?1607 * @returns ```true``` if extrinsic success, otherwise ```false```1608 */1609 async setAllowanceForAll(signer: TSigner, collectionId: number, operator: ICrossAccountId, approved: boolean): Promise<boolean> {1610 const result = await this.helper.executeExtrinsic(1611 signer,1612 'api.tx.unique.setAllowanceForAll', [collectionId, operator, approved],1613 true,1614 );1615 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'ApprovedForAll');1616 }1617}161816191620class NFTGroup extends NFTnRFT {1621 /**1622 * Get collection object1623 * @param collectionId ID of collection1624 * @example getCollectionObject(2);1625 * @returns instance of UniqueNFTCollection1626 */1627 getCollectionObject(collectionId: number): UniqueNFTCollection {1628 return new UniqueNFTCollection(collectionId, this.helper);1629 }16301631 /**1632 * Get token object1633 * @param collectionId ID of collection1634 * @param tokenId ID of token1635 * @example getTokenObject(10, 5);1636 * @returns instance of UniqueNFTToken1637 */1638 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1639 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1640 }16411642 /**1643 * Is token approved to transfer1644 * @param collectionId ID of collection1645 * @param tokenId ID of token1646 * @param toAccountObj address to be approved1647 * @returns ```true``` if extrinsic success, otherwise ```false```1648 */1649 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1650 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1651 }16521653 /**1654 * Changes the owner of the token.1655 *1656 * @param signer keyring of signer1657 * @param collectionId ID of collection1658 * @param tokenId ID of token1659 * @param addressObj address of a new owner1660 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1661 * @returns ```true``` if extrinsic success, otherwise ```false```1662 */1663 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1664 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1665 }16661667 /**1668 *1669 * Change ownership of a NFT on behalf of the owner.1670 *1671 * @param signer keyring of signer1672 * @param collectionId ID of collection1673 * @param tokenId ID of token1674 * @param fromAddressObj address on behalf of which the token will be sent1675 * @param toAddressObj new token owner1676 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1677 * @returns ```true``` if extrinsic success, otherwise ```false```1678 */1679 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1680 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1681 }16821683 /**1684 * Get tokens nested in the provided token1685 * @param collectionId ID of collection1686 * @param tokenId ID of token1687 * @param blockHashAt optionally query the data at the block with this hash1688 * @example getTokenChildren(10, 5);1689 * @returns tokens whose depth of nesting is <= 51690 */1691 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1692 let children;1693 if(typeof blockHashAt === 'undefined') {1694 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1695 } else {1696 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1697 }16981699 return children.toJSON().map((x: any) => {1700 return {collectionId: x.collection, tokenId: x.token};1701 });1702 }17031704 /**1705 * Mint new collection1706 * @param signer keyring of signer1707 * @param collectionOptions Collection options1708 * @example1709 * mintCollection(aliceKeyring, {1710 * name: 'New',1711 * description: 'New collection',1712 * tokenPrefix: 'NEW',1713 * })1714 * @returns object of the created collection1715 */1716 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1717 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1718 }17191720 /**1721 * Mint new token1722 * @param signer keyring of signer1723 * @param data token data1724 * @returns created token object1725 */1726 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1727 const creationResult = await this.helper.executeExtrinsic(1728 signer,1729 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1730 nft: {1731 properties: data.properties,1732 },1733 }],1734 true,1735 );1736 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1737 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1738 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1739 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1740 }17411742 /**1743 * Mint multiple NFT tokens1744 * @param signer keyring of signer1745 * @param collectionId ID of collection1746 * @param tokens array of tokens with owner and properties1747 * @example1748 * mintMultipleTokens(aliceKeyring, 10, [{1749 * owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1750 * properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1751 * },{1752 * owner: {Ethereum: "0x9F0583DbB855d..."},1753 * properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1754 * }]);1755 * @returns ```true``` if extrinsic success, otherwise ```false```1756 */1757 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1758 const creationResult = await this.helper.executeExtrinsic(1759 signer,1760 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1761 true,1762 );1763 const collection = this.getCollectionObject(collectionId);1764 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1765 }17661767 /**1768 * Mint multiple NFT tokens with one owner1769 * @param signer keyring of signer1770 * @param collectionId ID of collection1771 * @param owner tokens owner1772 * @param tokens array of tokens with owner and properties1773 * @example1774 * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1775 * properties: [{1776 * key: "gender",1777 * value: "female",1778 * },{1779 * key: "age",1780 * value: "33",1781 * }],1782 * }]);1783 * @returns array of newly created tokens1784 */1785 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1786 const rawTokens = [];1787 for (const token of tokens) {1788 const raw = {NFT: {properties: token.properties}};1789 rawTokens.push(raw);1790 }1791 const creationResult = await this.helper.executeExtrinsic(1792 signer,1793 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1794 true,1795 );1796 const collection = this.getCollectionObject(collectionId);1797 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1798 }17991800 /**1801 * Set, change, or remove approved address to transfer the ownership of the NFT.1802 *1803 * @param signer keyring of signer1804 * @param collectionId ID of collection1805 * @param tokenId ID of token1806 * @param toAddressObj address to approve1807 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1808 * @returns ```true``` if extrinsic success, otherwise ```false```1809 */1810 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1811 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1812 }1813}181418151816class RFTGroup extends NFTnRFT {1817 /**1818 * Get collection object1819 * @param collectionId ID of collection1820 * @example getCollectionObject(2);1821 * @returns instance of UniqueRFTCollection1822 */1823 getCollectionObject(collectionId: number): UniqueRFTCollection {1824 return new UniqueRFTCollection(collectionId, this.helper);1825 }18261827 /**1828 * Get token object1829 * @param collectionId ID of collection1830 * @param tokenId ID of token1831 * @example getTokenObject(10, 5);1832 * @returns instance of UniqueNFTToken1833 */1834 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1835 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1836 }18371838 /**1839 * Get top 10 token owners with the largest number of pieces1840 * @param collectionId ID of collection1841 * @param tokenId ID of token1842 * @example getTokenTop10Owners(10, 5);1843 * @returns array of top 10 owners1844 */1845 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1846 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1847 }18481849 /**1850 * Get number of pieces owned by address1851 * @param collectionId ID of collection1852 * @param tokenId ID of token1853 * @param addressObj address token owner1854 * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1855 * @returns number of pieces ownerd by address1856 */1857 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1858 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1859 }18601861 /**1862 * Transfer pieces of token to another address1863 * @param signer keyring of signer1864 * @param collectionId ID of collection1865 * @param tokenId ID of token1866 * @param addressObj address of a new owner1867 * @param amount number of pieces to be transfered1868 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1869 * @returns ```true``` if extrinsic success, otherwise ```false```1870 */1871 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1872 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1873 }18741875 /**1876 * Change ownership of some pieces of RFT on behalf of the owner.1877 * @param signer keyring of signer1878 * @param collectionId ID of collection1879 * @param tokenId ID of token1880 * @param fromAddressObj address on behalf of which the token will be sent1881 * @param toAddressObj new token owner1882 * @param amount number of pieces to be transfered1883 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1884 * @returns ```true``` if extrinsic success, otherwise ```false```1885 */1886 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1887 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1888 }18891890 /**1891 * Mint new collection1892 * @param signer keyring of signer1893 * @param collectionOptions Collection options1894 * @example1895 * mintCollection(aliceKeyring, {1896 * name: 'New',1897 * description: 'New collection',1898 * tokenPrefix: 'NEW',1899 * })1900 * @returns object of the created collection1901 */1902 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1903 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1904 }19051906 /**1907 * Mint new token1908 * @param signer keyring of signer1909 * @param data token data1910 * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1911 * @returns created token object1912 */1913 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1914 const creationResult = await this.helper.executeExtrinsic(1915 signer,1916 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1917 refungible: {1918 pieces: data.pieces,1919 properties: data.properties,1920 },1921 }],1922 true,1923 );1924 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1925 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1926 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1927 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1928 }19291930 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1931 throw Error('Not implemented');1932 const creationResult = await this.helper.executeExtrinsic(1933 signer,1934 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1935 true, // `Unable to mint RFT tokens for ${label}`,1936 );1937 const collection = this.getCollectionObject(collectionId);1938 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1939 }19401941 /**1942 * Mint multiple RFT tokens with one owner1943 * @param signer keyring of signer1944 * @param collectionId ID of collection1945 * @param owner tokens owner1946 * @param tokens array of tokens with properties and pieces1947 * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1948 * @returns array of newly created RFT tokens1949 */1950 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1951 const rawTokens = [];1952 for (const token of tokens) {1953 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1954 rawTokens.push(raw);1955 }1956 const creationResult = await this.helper.executeExtrinsic(1957 signer,1958 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1959 true,1960 );1961 const collection = this.getCollectionObject(collectionId);1962 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1963 }19641965 /**1966 * Destroys a concrete instance of RFT.1967 * @param signer keyring of signer1968 * @param collectionId ID of collection1969 * @param tokenId ID of token1970 * @param amount number of pieces to be burnt1971 * @example burnToken(aliceKeyring, 10, 5);1972 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1973 */1974 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1975 return await super.burnToken(signer, collectionId, tokenId, amount);1976 }19771978 /**1979 * Destroys a concrete instance of RFT on behalf of the owner.1980 * @param signer keyring of signer1981 * @param collectionId ID of collection1982 * @param tokenId ID of token1983 * @param fromAddressObj address on behalf of which the token will be burnt1984 * @param amount number of pieces to be burnt1985 * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1986 * @returns ```true``` if extrinsic success, otherwise ```false```1987 */1988 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1989 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1990 }19911992 /**1993 * Set, change, or remove approved address to transfer the ownership of the RFT.1994 *1995 * @param signer keyring of signer1996 * @param collectionId ID of collection1997 * @param tokenId ID of token1998 * @param toAddressObj address to approve1999 * @param amount number of pieces to be approved2000 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);2001 * @returns true if the token success, otherwise false2002 */2003 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {2004 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);2005 }20062007 /**2008 * Get total number of pieces2009 * @param collectionId ID of collection2010 * @param tokenId ID of token2011 * @example getTokenTotalPieces(10, 5);2012 * @returns number of pieces2013 */2014 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {2015 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();2016 }20172018 /**2019 * Change number of token pieces. Signer must be the owner of all token pieces.2020 * @param signer keyring of signer2021 * @param collectionId ID of collection2022 * @param tokenId ID of token2023 * @param amount new number of pieces2024 * @example repartitionToken(aliceKeyring, 10, 5, 12345n);2025 * @returns true if the repartion was success, otherwise false2026 */2027 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {2028 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);2029 const repartitionResult = await this.helper.executeExtrinsic(2030 signer,2031 'api.tx.unique.repartition', [collectionId, tokenId, amount],2032 true,2033 );2034 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');2035 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');2036 }2037}203820392040class FTGroup extends CollectionGroup {2041 /**2042 * Get collection object2043 * @param collectionId ID of collection2044 * @example getCollectionObject(2);2045 * @returns instance of UniqueFTCollection2046 */2047 getCollectionObject(collectionId: number): UniqueFTCollection {2048 return new UniqueFTCollection(collectionId, this.helper);2049 }20502051 /**2052 * Mint new fungible collection2053 * @param signer keyring of signer2054 * @param collectionOptions Collection options2055 * @param decimalPoints number of token decimals2056 * @example2057 * mintCollection(aliceKeyring, {2058 * name: 'New',2059 * description: 'New collection',2060 * tokenPrefix: 'NEW',2061 * }, 18)2062 * @returns newly created fungible collection2063 */2064 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {2065 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object2066 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');2067 collectionOptions.mode = {fungible: decimalPoints};2068 for (const key of ['name', 'description', 'tokenPrefix']) {2069 if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);2070 }2071 const creationResult = await this.helper.executeExtrinsic(2072 signer,2073 'api.tx.unique.createCollectionEx', [collectionOptions],2074 true,2075 );2076 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));2077 }20782079 /**2080 * Mint tokens2081 * @param signer keyring of signer2082 * @param collectionId ID of collection2083 * @param owner address owner of new tokens2084 * @param amount amount of tokens to be meanted2085 * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);2086 * @returns ```true``` if extrinsic success, otherwise ```false```2087 */2088 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {2089 const creationResult = await this.helper.executeExtrinsic(2090 signer,2091 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {2092 fungible: {2093 value: amount,2094 },2095 }],2096 true, // `Unable to mint fungible tokens for ${label}`,2097 );2098 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2099 }21002101 /**2102 * Mint multiple Fungible tokens with one owner2103 * @param signer keyring of signer2104 * @param collectionId ID of collection2105 * @param owner tokens owner2106 * @param tokens array of tokens with properties and pieces2107 * @returns ```true``` if extrinsic success, otherwise ```false```2108 */2109 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {2110 const rawTokens = [];2111 for (const token of tokens) {2112 const raw = {Fungible: {Value: token.value}};2113 rawTokens.push(raw);2114 }2115 const creationResult = await this.helper.executeExtrinsic(2116 signer,2117 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],2118 true,2119 );2120 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2121 }21222123 /**2124 * Get the top 10 owners with the largest balance for the Fungible collection2125 * @param collectionId ID of collection2126 * @example getTop10Owners(10);2127 * @returns array of ```ICrossAccountId```2128 */2129 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {2130 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);2131 }21322133 /**2134 * Get account balance2135 * @param collectionId ID of collection2136 * @param addressObj address of owner2137 * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})2138 * @returns amount of fungible tokens owned by address2139 */2140 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {2141 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();2142 }21432144 /**2145 * Transfer tokens to address2146 * @param signer keyring of signer2147 * @param collectionId ID of collection2148 * @param toAddressObj address recipient2149 * @param amount amount of tokens to be sent2150 * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2151 * @returns ```true``` if extrinsic success, otherwise ```false```2152 */2153 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2154 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);2155 }21562157 /**2158 * Transfer some tokens on behalf of the owner.2159 * @param signer keyring of signer2160 * @param collectionId ID of collection2161 * @param fromAddressObj address on behalf of which tokens will be sent2162 * @param toAddressObj address where token to be sent2163 * @param amount number of tokens to be sent2164 * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);2165 * @returns ```true``` if extrinsic success, otherwise ```false```2166 */2167 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2168 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2169 }21702171 /**2172 * Destroy some amount of tokens2173 * @param signer keyring of signer2174 * @param collectionId ID of collection2175 * @param amount amount of tokens to be destroyed2176 * @example burnTokens(aliceKeyring, 10, 1000n);2177 * @returns ```true``` if extrinsic success, otherwise ```false```2178 */2179 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {2180 return await super.burnToken(signer, collectionId, 0, amount);2181 }21822183 /**2184 * Burn some tokens on behalf of the owner.2185 * @param signer keyring of signer2186 * @param collectionId ID of collection2187 * @param fromAddressObj address on behalf of which tokens will be burnt2188 * @param amount amount of tokens to be burnt2189 * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2190 * @returns ```true``` if extrinsic success, otherwise ```false```2191 */2192 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {2193 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2194 }21952196 /**2197 * Get total collection supply2198 * @param collectionId2199 * @returns2200 */2201 async getTotalPieces(collectionId: number): Promise<bigint> {2202 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2203 }22042205 /**2206 * Set, change, or remove approved address to transfer tokens.2207 *2208 * @param signer keyring of signer2209 * @param collectionId ID of collection2210 * @param toAddressObj address to be approved2211 * @param amount amount of tokens to be approved2212 * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2213 * @returns ```true``` if extrinsic success, otherwise ```false```2214 */2215 approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2216 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2217 }22182219 /**2220 * Get amount of fungible tokens approved to transfer2221 * @param collectionId ID of collection2222 * @param fromAddressObj owner of tokens2223 * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2224 * @returns number of tokens approved for the transfer2225 */2226 getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2227 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2228 }2229}223022312232class ChainGroup extends HelperGroup<ChainHelperBase> {2233 /**2234 * Get system properties of a chain2235 * @example getChainProperties();2236 * @returns ss58Format, token decimals, and token symbol2237 */2238 getChainProperties(): IChainProperties {2239 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2240 return {2241 ss58Format: properties.ss58Format.toJSON(),2242 tokenDecimals: properties.tokenDecimals.toJSON(),2243 tokenSymbol: properties.tokenSymbol.toJSON(),2244 };2245 }22462247 /**2248 * Get chain header2249 * @example getLatestBlockNumber();2250 * @returns the number of the last block2251 */2252 async getLatestBlockNumber(): Promise<number> {2253 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2254 }22552256 /**2257 * Get block hash by block number2258 * @param blockNumber number of block2259 * @example getBlockHashByNumber(12345);2260 * @returns hash of a block2261 */2262 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2263 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2264 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2265 return blockHash;2266 }22672268 // TODO add docs2269 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2270 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2271 if (!blockHash) return null;2272 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2273 }22742275 /**2276 * Get latest relay block2277 * @returns {number} relay block2278 */2279 async getRelayBlockNumber(): Promise<bigint> {2280 const blockNumber = (await this.helper.callRpc('api.query.parachainSystem.validationData')).toJSON().relayParentNumber;2281 return BigInt(blockNumber);2282 }22832284 /**2285 * Get account nonce2286 * @param address substrate address2287 * @example getNonce("5GrwvaEF5zXb26Fz...");2288 * @returns number, account's nonce2289 */2290 async getNonce(address: TSubstrateAccount): Promise<number> {2291 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2292 }2293}22942295class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2296 /**2297 * Get substrate address balance2298 * @param address substrate address2299 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2300 * @returns amount of tokens on address2301 */2302 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2303 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2304 }23052306 /**2307 * Transfer tokens to substrate address2308 * @param signer keyring of signer2309 * @param address substrate address of a recipient2310 * @param amount amount of tokens to be transfered2311 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2312 * @returns ```true``` if extrinsic success, otherwise ```false```2313 */2314 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2315 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true/*, `Unable to transfer balance from ${this.helper.getSignerAddress(signer)} to ${address}`*/);23162317 let transfer = {from: null, to: null, amount: 0n} as any;2318 result.result.events.forEach(({event: {data, method, section}}) => {2319 if ((section === 'balances') && (method === 'Transfer')) {2320 transfer = {2321 from: this.helper.address.normalizeSubstrate(data[0]),2322 to: this.helper.address.normalizeSubstrate(data[1]),2323 amount: BigInt(data[2]),2324 };2325 }2326 });2327 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from2328 && this.helper.address.normalizeSubstrate(address) === transfer.to2329 && BigInt(amount) === transfer.amount;2330 return isSuccess;2331 }23322333 /**2334 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2335 * @param address substrate address2336 * @returns2337 */2338 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2339 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2340 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2341 }23422343 async getLocked(address: TSubstrateAccount): Promise<[{id: string, amount: bigint, reason: string}]> {2344 const locks = (await this.helper.callRpc('api.query.balances.locks', [address])).toHuman();2345 return locks.map((lock: any) => {return {id: lock.id, amount: BigInt(lock.amount.replace(/,/g, '')), reasons: lock.reasons};});2346 }2347}23482349class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2350 /**2351 * Get ethereum address balance2352 * @param address ethereum address2353 * @example getEthereum("0x9F0583DbB855d...")2354 * @returns amount of tokens on address2355 */2356 async getEthereum(address: TEthereumAccount): Promise<bigint> {2357 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2358 }23592360 /**2361 * Transfer tokens to address2362 * @param signer keyring of signer2363 * @param address Ethereum address of a recipient2364 * @param amount amount of tokens to be transfered2365 * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2366 * @returns ```true``` if extrinsic success, otherwise ```false```2367 */2368 async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2369 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);23702371 let transfer = {from: null, to: null, amount: 0n} as any;2372 result.result.events.forEach(({event: {data, method, section}}) => {2373 if ((section === 'balances') && (method === 'Transfer')) {2374 transfer = {2375 from: data[0].toString(),2376 to: data[1].toString(),2377 amount: BigInt(data[2]),2378 };2379 }2380 });2381 const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from2382 && address === transfer.to2383 && BigInt(amount) === transfer.amount;2384 return isSuccess;2385 }2386}23872388class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2389 subBalanceGroup: SubstrateBalanceGroup<T>;2390 ethBalanceGroup: EthereumBalanceGroup<T>;23912392 constructor(helper: T) {2393 super(helper);2394 this.subBalanceGroup = new SubstrateBalanceGroup(helper);2395 this.ethBalanceGroup = new EthereumBalanceGroup(helper);2396 }23972398 getCollectionCreationPrice(): bigint {2399 return 2n * this.getOneTokenNominal();2400 }2401 /**2402 * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2403 * @example getOneTokenNominal()2404 * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2405 */2406 getOneTokenNominal(): bigint {2407 const chainProperties = this.helper.chain.getChainProperties();2408 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2409 }24102411 /**2412 * Get substrate address balance2413 * @param address substrate address2414 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2415 * @returns amount of tokens on address2416 */2417 getSubstrate(address: TSubstrateAccount): Promise<bigint> {2418 return this.subBalanceGroup.getSubstrate(address);2419 }24202421 /**2422 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2423 * @param address substrate address2424 * @returns2425 */2426 getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2427 return this.subBalanceGroup.getSubstrateFull(address);2428 }24292430 /**2431 * Get locked balances2432 * @param address substrate address2433 * @returns locked balances with reason via api.query.balances.locks2434 */2435 getLocked(address: TSubstrateAccount) {2436 return this.subBalanceGroup.getLocked(address);2437 }24382439 /**2440 * Get ethereum address balance2441 * @param address ethereum address2442 * @example getEthereum("0x9F0583DbB855d...")2443 * @returns amount of tokens on address2444 */2445 getEthereum(address: TEthereumAccount): Promise<bigint> {2446 return this.ethBalanceGroup.getEthereum(address);2447 }24482449 async setBalanceSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint, reservedAmount = 0n) {2450 await this.helper.executeExtrinsic(signer, 'api.tx.balances.setBalance', [address, amount, reservedAmount], true);2451 }24522453 /**2454 * Transfer tokens to substrate address2455 * @param signer keyring of signer2456 * @param address substrate address of a recipient2457 * @param amount amount of tokens to be transfered2458 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2459 * @returns ```true``` if extrinsic success, otherwise ```false```2460 */2461 transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2462 return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2463 }24642465 async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2466 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);24672468 let transfer = {from: null, to: null, amount: 0n} as any;2469 result.result.events.forEach(({event: {data, method, section}}) => {2470 if ((section === 'balances') && (method === 'Transfer')) {2471 transfer = {2472 from: this.helper.address.normalizeSubstrate(data[0]),2473 to: this.helper.address.normalizeSubstrate(data[1]),2474 amount: BigInt(data[2]),2475 };2476 }2477 });2478 let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2479 isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2480 isSuccess = isSuccess && BigInt(amount) === transfer.amount;2481 return isSuccess;2482 }24832484 /**2485 * Transfer tokens with the unlock period2486 * @param signer signers Keyring2487 * @param address Substrate address of recipient2488 * @param schedule Schedule params2489 * @example vestedTransfer(signer, recepient.address, 20000, 100, 10, 50 * nominal); // total amount of vested tokens will be 100 * 50 = 50002490 */2491 async vestedTransfer(signer: TSigner, address: TSubstrateAccount, schedule: {start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}): Promise<void> {2492 const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.vestedTransfer', [address, schedule]);2493 const event = result.result.events2494 .find(e => e.event.section === 'vesting' &&2495 e.event.method === 'VestingScheduleAdded' &&2496 e.event.data[0].toHuman() === signer.address);2497 if (!event) throw Error('Cannot find transfer in events');2498 }24992500 /**2501 * Get schedule for recepient of vested transfer2502 * @param address Substrate address of recipient2503 * @returns2504 */2505 async getVestingSchedules(address: TSubstrateAccount): Promise<{start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}[]> {2506 const schedule = (await this.helper.callRpc('api.query.vesting.vestingSchedules', [address])).toJSON();2507 return schedule.map((schedule: any) => {2508 return {2509 start: BigInt(schedule.start),2510 period: BigInt(schedule.period),2511 periodCount: BigInt(schedule.periodCount),2512 perPeriod: BigInt(schedule.perPeriod),2513 };2514 });2515 }25162517 /**2518 * Claim vested tokens2519 * @param signer signers Keyring2520 */2521 async claim(signer: TSigner) {2522 const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.claim', []);2523 const event = result.result.events2524 .find(e => e.event.section === 'vesting' &&2525 e.event.method === 'Claimed' &&2526 e.event.data[0].toHuman() === signer.address);2527 if (!event) throw Error('Cannot find claim in events');2528 }2529}25302531class AddressGroup extends HelperGroup<ChainHelperBase> {2532 /**2533 * Normalizes the address to the specified ss58 format, by default ```42```.2534 * @param address substrate address2535 * @param ss58Format format for address conversion, by default ```42```2536 * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2537 * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2538 */2539 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2540 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2541 }25422543 /**2544 * Get address in the connected chain format2545 * @param address substrate address2546 * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2547 * @returns address in chain format2548 */2549 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2550 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2551 }25522553 /**2554 * Get substrate mirror of an ethereum address2555 * @param ethAddress ethereum address2556 * @param toChainFormat false for normalized account2557 * @example ethToSubstrate('0x9F0583DbB855d...')2558 * @returns substrate mirror of a provided ethereum address2559 */2560 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2561 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2562 }25632564 /**2565 * Get ethereum mirror of a substrate address2566 * @param subAddress substrate account2567 * @example substrateToEth("5DnSF6RRjwteE3BrC...")2568 * @returns ethereum mirror of a provided substrate address2569 */2570 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2571 return CrossAccountId.translateSubToEth(subAddress);2572 }25732574 /**2575 * Encode key to substrate address2576 * @param key key for encoding address2577 * @param ss58Format prefix for encoding to the address of the corresponding network2578 * @returns encoded substrate address2579 */2580 encodeSubstrateAddress (key: Uint8Array | string | bigint, ss58Format = 42): string {2581 const u8a :Uint8Array = typeof key === 'string'2582 ? hexToU8a(key)2583 : typeof key === 'bigint'2584 ? hexToU8a(key.toString(16))2585 : key;25862587 if (ss58Format < 0 || ss58Format > 16383 || [46, 47].includes(ss58Format)) {2588 throw new Error(`ss58Format is not valid, received ${typeofss58Format} "${ss58Format}"`);2589 }25902591 const allowedDecodedLengths = [1, 2, 4, 8, 32, 33];2592 if (!allowedDecodedLengths.includes(u8a.length)) {2593 throw new Error(`key length is not valid, received ${u8a.length}, valid values are ${allowedDecodedLengths.join(', ')}`);2594 }25952596 const u8aPrefix = ss58Format < 642597 ? new Uint8Array([ss58Format])2598 : new Uint8Array([2599 ((ss58Format & 0xfc) >> 2) | 0x40,2600 (ss58Format >> 8) | ((ss58Format & 0x03) << 6),2601 ]);26022603 const input = u8aConcat(u8aPrefix, u8a);26042605 return base58Encode(u8aConcat(2606 input,2607 blake2AsU8a(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1),2608 ));2609 }26102611 /**2612 * Restore substrate address from bigint representation2613 * @param number decimal representation of substrate address2614 * @returns substrate address2615 */2616 restoreCrossAccountFromBigInt(number: bigint): TSubstrateAccount {2617 if (this.helper.api === null) {2618 throw 'Not connected';2619 }2620 const res = this.helper.api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();2621 if (res === undefined || res === null) {2622 throw 'Restore address error';2623 }2624 return res.toString();2625 }26262627 /**2628 * Convert etherium cross account id to substrate cross account id2629 * @param ethCrossAccount etherium cross account2630 * @returns substrate cross account id2631 */2632 convertCrossAccountFromEthCrossAccount(ethCrossAccount: IEthCrossAccountId): ICrossAccountId {2633 if (ethCrossAccount.sub === '0') {2634 return {Ethereum: ethCrossAccount.eth.toLocaleLowerCase()};2635 }26362637 const ss58 = this.restoreCrossAccountFromBigInt(BigInt(ethCrossAccount.sub));2638 return {Substrate: ss58};2639 }26402641 paraSiblingSovereignAccount(paraid: number) {2642 // We are getting a *sibling* parachain sovereign account,2643 // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c2644 const siblingPrefix = '0x7369626c';26452646 const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2647 const suffix = '000000000000000000000000000000000000000000000000';26482649 return siblingPrefix + encodedParaId + suffix;2650 }2651}26522653class StakingGroup extends HelperGroup<UniqueHelper> {2654 /**2655 * Stake tokens for App Promotion2656 * @param signer keyring of signer2657 * @param amountToStake amount of tokens to stake2658 * @param label extra label for log2659 * @returns2660 */2661 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2662 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2663 const _stakeResult = await this.helper.executeExtrinsic(2664 signer, 'api.tx.appPromotion.stake',2665 [amountToStake], true,2666 );2667 // TODO extract info from stakeResult2668 return true;2669 }26702671 /**2672 * Unstake all staked tokens2673 * @param signer keyring of signer2674 * @param amountToUnstake amount of tokens to unstake2675 * @param label extra label for log2676 * @returns block hash where unstake happened2677 */2678 async unstakeAll(signer: TSigner, label?: string): Promise<string> {2679 if(typeof label === 'undefined') label = `${signer.address}`;2680 const unstakeResult = await this.helper.executeExtrinsic(2681 signer, 'api.tx.appPromotion.unstakeAll',2682 [], true,2683 );2684 return unstakeResult.blockHash;2685 }26862687 /**2688 * Unstake the part of a staked tokens2689 * @param signer keyring of signer2690 * @param amount amount of tokens to unstake2691 * @param label extra label for log2692 * @returns block hash where unstake happened2693 */2694 async unstakePartial(signer: TSigner, amount: bigint, label?: string): Promise<string> {2695 if(typeof label === 'undefined') label = `${signer.address}`;2696 const unstakeResult = await this.helper.executeExtrinsic(2697 signer, 'api.tx.appPromotion.unstakePartial',2698 [amount], true,2699 );2700 return unstakeResult.blockHash;2701 }27022703 /**2704 * Get total number of active stakes2705 * @param address substrate address2706 * @returns {number}2707 */2708 async getStakesNumber(address: ICrossAccountId): Promise<number> {2709 if (address.Ethereum) throw Error('only substrate address');2710 return (await this.helper.callRpc('api.query.appPromotion.stakesPerAccount', [address.Substrate])).toNumber();2711 }27122713 /**2714 * Get total staked amount for address2715 * @param address substrate or ethereum address2716 * @returns total staked amount2717 */2718 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2719 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2720 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2721 }27222723 /**2724 * Get total staked per block2725 * @param address substrate or ethereum address2726 * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2727 */2728 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2729 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2730 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2731 return {2732 block: block.toBigInt(),2733 amount: amount.toBigInt(),2734 };2735 });2736 }27372738 /**2739 * Get total pending unstake amount for address2740 * @param address substrate or ethereum address2741 * @returns total pending unstake amount2742 */2743 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2744 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2745 }27462747 /**2748 * Get pending unstake amount per block for address2749 * @param address substrate or ethereum address2750 * @returns array of pending stakes. `block` – the number of the block in which the unstake was made. `amount` - the number of tokens unstaked in the block2751 */2752 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2753 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2754 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2755 return {2756 block: block.toBigInt(),2757 amount: amount.toBigInt(),2758 };2759 });2760 return result;2761 }2762}27632764class SchedulerGroup extends HelperGroup<UniqueHelper> {2765 constructor(helper: UniqueHelper) {2766 super(helper);2767 }27682769 cancelScheduled(signer: TSigner, scheduledId: string) {2770 return this.helper.executeExtrinsic(2771 signer,2772 'api.tx.scheduler.cancelNamed',2773 [scheduledId],2774 true,2775 );2776 }27772778 changePriority(signer: TSigner, scheduledId: string, priority: number) {2779 return this.helper.executeExtrinsic(2780 signer,2781 'api.tx.scheduler.changeNamedPriority',2782 [scheduledId, priority],2783 true,2784 );2785 }27862787 scheduleAt<T extends UniqueHelper>(2788 executionBlockNumber: number,2789 options: ISchedulerOptions = {},2790 ) {2791 return this.schedule<T>('schedule', executionBlockNumber, options);2792 }27932794 scheduleAfter<T extends UniqueHelper>(2795 blocksBeforeExecution: number,2796 options: ISchedulerOptions = {},2797 ) {2798 return this.schedule<T>('scheduleAfter', blocksBeforeExecution, options);2799 }28002801 schedule<T extends UniqueHelper>(2802 scheduleFn: 'schedule' | 'scheduleAfter',2803 blocksNum: number,2804 options: ISchedulerOptions = {},2805 ) {2806 // eslint-disable-next-line @typescript-eslint/naming-convention2807 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2808 return this.helper.clone(ScheduledHelperType, {2809 scheduleFn,2810 blocksNum,2811 options,2812 }) as T;2813 }2814}28152816class CollatorSelectionGroup extends HelperGroup<UniqueHelper> {2817 //todo:collator documentation2818 addInvulnerable(signer: TSigner, address: string) {2819 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.addInvulnerable', [address]);2820 }28212822 removeInvulnerable(signer: TSigner, address: string) {2823 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.removeInvulnerable', [address]);2824 }28252826 async getInvulnerables(): Promise<string[]> {2827 return (await this.helper.callRpc('api.query.collatorSelection.invulnerables')).map((x: any) => x.toHuman());2828 }28292830 /** and also total max invulnerables */2831 maxCollators(): number {2832 return (this.helper.getApi().consts.configuration.defaultCollatorSelectionMaxCollators.toJSON() as number);2833 }28342835 async getDesiredCollators(): Promise<number> {2836 return (await this.helper.callRpc('api.query.configuration.collatorSelectionDesiredCollatorsOverride')).toNumber();2837 }28382839 setLicenseBond(signer: TSigner, amount: bigint) {2840 return this.helper.executeExtrinsic(signer, 'api.tx.configuration.setCollatorSelectionLicenseBond', [amount]);2841 }28422843 async getLicenseBond(): Promise<bigint> {2844 return (await this.helper.callRpc('api.query.configuration.collatorSelectionLicenseBondOverride')).toBigInt();2845 }28462847 obtainLicense(signer: TSigner) {2848 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.getLicense', []);2849 }28502851 releaseLicense(signer: TSigner) {2852 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.releaseLicense', []);2853 }28542855 forceReleaseLicense(signer: TSigner, released: string) {2856 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.forceReleaseLicense', [released]);2857 }28582859 async hasLicense(address: string): Promise<bigint> {2860 return (await this.helper.callRpc('api.query.collatorSelection.licenseDepositOf', [address])).toBigInt();2861 }28622863 onboard(signer: TSigner) {2864 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.onboard', []);2865 }28662867 offboard(signer: TSigner) {2868 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.offboard', []);2869 }28702871 async getCandidates(): Promise<string[]> {2872 return (await this.helper.callRpc('api.query.collatorSelection.candidates')).map((x: any) => x.toHuman());2873 }2874}28752876class PreimageGroup extends HelperGroup<UniqueHelper> {2877 async getPreimageInfo(h256: string) {2878 return (await this.helper.callRpc('api.query.preimage.statusFor', [h256])).toJSON();2879 }28802881 /**2882 * Create a preimage with a hex or a byte array.2883 * @param signer keyring of the signer.2884 * @param bytes preimage encoded in hex or a byte array, e.g. an extrinsic call.2885 * @example await notePreimage(preimageMaker,2886 * helper.constructApiCall('api.tx.identity.forceInsertIdentities', [identitiesToAdd]).method.toHex()2887 * );2888 * @returns promise of extrinsic execution.2889 */2890 notePreimage(signer: TSigner, bytes: string | Uint8Array) {2891 return this.helper.executeExtrinsic(signer, 'api.tx.preimage.notePreimage', [bytes]);2892 }28932894 /**2895 * Delete an existing preimage and return the deposit.2896 * @param signer keyring of the signer - either the owner or the preimage manager (sudo).2897 * @param h256 hash of the preimage.2898 * @returns promise of extrinsic execution.2899 */2900 unnotePreimage(signer: TSigner, h256: string) {2901 return this.helper.executeExtrinsic(signer, 'api.tx.preimage.unnotePreimage', [h256]);2902 }29032904 /**2905 * Request a preimage be uploaded to the chain without paying any fees or deposits.2906 * @param signer keyring of the signer - either the owner or the preimage manager (sudo).2907 * @param h256 hash of the preimage.2908 * @returns promise of extrinsic execution.2909 */2910 requestPreimage(signer: TSigner, h256: string) {2911 return this.helper.executeExtrinsic(signer, 'api.tx.preimage.requestPreimage', [h256]);2912 }29132914 /**2915 * Clear a previously made request for a preimage.2916 * @param signer keyring of the signer - either the owner or the preimage manager (sudo).2917 * @param h256 hash of the preimage.2918 * @returns promise of extrinsic execution.2919 */2920 unrequestPreimage(signer: TSigner, h256: string) {2921 return this.helper.executeExtrinsic(signer, 'api.tx.preimage.unrequestPreimage', [h256]);2922 }2923}29242925class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2926 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2927 await this.helper.executeExtrinsic(2928 signer,2929 'api.tx.foreignAssets.registerForeignAsset',2930 [ownerAddress, location, metadata],2931 true,2932 );2933 }29342935 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2936 await this.helper.executeExtrinsic(2937 signer,2938 'api.tx.foreignAssets.updateForeignAsset',2939 [foreignAssetId, location, metadata],2940 true,2941 );2942 }2943}29442945class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2946 palletName: string;29472948 constructor(helper: T, palletName: string) {2949 super(helper);29502951 this.palletName = palletName;2952 }29532954 async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: any) {2955 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, weightLimit], true);2956 }29572958 async setSafeXcmVersion(signer: TSigner, version: number) {2959 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.forceDefaultXcmVersion`, [version], true);2960 }29612962 async teleportAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number) {2963 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.teleportAssets`, [destination, beneficiary, assets, feeAssetItem], true);2964 }29652966 async teleportNativeAsset(signer: TSigner, destinationParaId: number, targetAccount: Uint8Array, amount: bigint, xcmVersion = 3) {2967 const destinationContent = {2968 parents: 0,2969 interior: {2970 X1: {2971 Parachain: destinationParaId,2972 },2973 },2974 };29752976 const beneficiaryContent = {2977 parents: 0,2978 interior: {2979 X1: {2980 AccountId32: {2981 network: 'Any',2982 id: targetAccount,2983 },2984 },2985 },2986 };29872988 const assetsContent = [2989 {2990 id: {2991 Concrete: {2992 parents: 0,2993 interior: 'Here',2994 },2995 },2996 fun: {2997 Fungible: amount,2998 },2999 },3000 ];30013002 let destination;3003 let beneficiary;3004 let assets;30053006 if (xcmVersion == 2) {3007 destination = {V1: destinationContent};3008 beneficiary = {V1: beneficiaryContent};3009 assets = {V1: assetsContent};30103011 } else if (xcmVersion == 3) {3012 destination = {V2: destinationContent};3013 beneficiary = {V2: beneficiaryContent};3014 assets = {V2: assetsContent};30153016 } else {3017 throw Error('Unknown XCM version: ' + xcmVersion);3018 }30193020 const feeAssetItem = 0;30213022 await this.teleportAssets(signer, destination, beneficiary, assets, feeAssetItem);3023 }30243025 async send(signer: IKeyringPair, destination: any, message: any) {3026 await this.helper.executeExtrinsic(3027 signer,3028 `api.tx.${this.palletName}.send`,3029 [3030 destination,3031 message,3032 ],3033 true,3034 );3035 }3036}30373038class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {3039 async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: any) {3040 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);3041 }30423043 async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: any) {3044 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);3045 }30463047 async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: any) {3048 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);3049 }3050}30513052class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {3053 async accounts(address: string, currencyId: any) {3054 const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;3055 return BigInt(free);3056 }3057}30583059class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {3060 async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {3061 await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);3062 }30633064 async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {3065 await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);3066 }30673068 async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {3069 await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);3070 }30713072 async account(assetId: string | number, address: string) {3073 const accountAsset = (3074 await this.helper.callRpc('api.query.assets.account', [assetId, address])3075 ).toJSON()! as any;30763077 if (accountAsset !== null) {3078 return BigInt(accountAsset['balance']);3079 } else {3080 return null;3081 }3082 }3083}30843085class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {3086 async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {3087 await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);3088 }3089}30903091class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {3092 makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {3093 const apiPrefix = 'api.tx.assetManager.';30943095 const registerTx = this.helper.constructApiCall(3096 apiPrefix + 'registerForeignAsset',3097 [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],3098 );30993100 const setUnitsTx = this.helper.constructApiCall(3101 apiPrefix + 'setAssetUnitsPerSecond',3102 [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],3103 );31043105 const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);3106 const encodedProposal = batchCall?.method.toHex() || '';3107 return encodedProposal;3108 }31093110 async assetTypeId(location: any) {3111 return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);3112 }3113}31143115class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {3116 notePreimagePallet: string;31173118 constructor(helper: MoonbeamHelper, options: {[key: string]: any} = {}) {3119 super(helper);3120 this.notePreimagePallet = options.notePreimagePallet;3121 }31223123 async notePreimage(signer: TSigner, encodedProposal: string) {3124 await this.helper.executeExtrinsic(signer, `api.tx.${this.notePreimagePallet}.notePreimage`, [encodedProposal], true);3125 }31263127 externalProposeMajority(proposal: any) {3128 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposal]);3129 }31303131 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {3132 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);3133 }31343135 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {3136 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);3137 }3138}31393140class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {3141 collective: string;31423143 constructor(helper: MoonbeamHelper, collective: string) {3144 super(helper);31453146 this.collective = collective;3147 }31483149 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {3150 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);3151 }31523153 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {3154 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);3155 }31563157 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: any, lengthBound: number) {3158 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);3159 }31603161 async proposalCount() {3162 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));3163 }3164}31653166export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;3167export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;31683169export class UniqueHelper extends ChainHelperBase {3170 balance: BalanceGroup<UniqueHelper>;3171 collection: CollectionGroup;3172 nft: NFTGroup;3173 rft: RFTGroup;3174 ft: FTGroup;3175 staking: StakingGroup;3176 scheduler: SchedulerGroup;3177 collatorSelection: CollatorSelectionGroup;3178 preimage: PreimageGroup;3179 foreignAssets: ForeignAssetsGroup;3180 xcm: XcmGroup<UniqueHelper>;3181 xTokens: XTokensGroup<UniqueHelper>;3182 tokens: TokensGroup<UniqueHelper>;31833184 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3185 super(logger, options.helperBase ?? UniqueHelper);31863187 this.balance = new BalanceGroup(this);3188 this.collection = new CollectionGroup(this);3189 this.nft = new NFTGroup(this);3190 this.rft = new RFTGroup(this);3191 this.ft = new FTGroup(this);3192 this.staking = new StakingGroup(this);3193 this.scheduler = new SchedulerGroup(this);3194 this.collatorSelection = new CollatorSelectionGroup(this);3195 this.preimage = new PreimageGroup(this);3196 this.foreignAssets = new ForeignAssetsGroup(this);3197 this.xcm = new XcmGroup(this, 'polkadotXcm');3198 this.xTokens = new XTokensGroup(this);3199 this.tokens = new TokensGroup(this);3200 }32013202 getSudo<T extends UniqueHelper>() {3203 // eslint-disable-next-line @typescript-eslint/naming-convention3204 const SudoHelperType = SudoHelper(this.helperBase);3205 return this.clone(SudoHelperType) as T;3206 }3207}32083209export class XcmChainHelper extends ChainHelperBase {3210 async connect(wsEndpoint: string, _listeners?: any): Promise<void> {3211 const wsProvider = new WsProvider(wsEndpoint);3212 this.api = new ApiPromise({3213 provider: wsProvider,3214 });3215 await this.api.isReadyOrError;3216 this.network = await UniqueHelper.detectNetwork(this.api);3217 }3218}32193220export class RelayHelper extends XcmChainHelper {3221 balance: SubstrateBalanceGroup<RelayHelper>;3222 xcm: XcmGroup<RelayHelper>;32233224 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3225 super(logger, options.helperBase ?? RelayHelper);32263227 this.balance = new SubstrateBalanceGroup(this);3228 this.xcm = new XcmGroup(this, 'xcmPallet');3229 }3230}32313232export class WestmintHelper extends XcmChainHelper {3233 balance: SubstrateBalanceGroup<WestmintHelper>;3234 xcm: XcmGroup<WestmintHelper>;3235 assets: AssetsGroup<WestmintHelper>;3236 xTokens: XTokensGroup<WestmintHelper>;32373238 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3239 super(logger, options.helperBase ?? WestmintHelper);32403241 this.balance = new SubstrateBalanceGroup(this);3242 this.xcm = new XcmGroup(this, 'polkadotXcm');3243 this.assets = new AssetsGroup(this);3244 this.xTokens = new XTokensGroup(this);3245 }3246}32473248export class MoonbeamHelper extends XcmChainHelper {3249 balance: EthereumBalanceGroup<MoonbeamHelper>;3250 assetManager: MoonbeamAssetManagerGroup;3251 assets: AssetsGroup<MoonbeamHelper>;3252 xTokens: XTokensGroup<MoonbeamHelper>;3253 democracy: MoonbeamDemocracyGroup;3254 collective: {3255 council: MoonbeamCollectiveGroup,3256 techCommittee: MoonbeamCollectiveGroup,3257 };32583259 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3260 super(logger, options.helperBase ?? MoonbeamHelper);32613262 this.balance = new EthereumBalanceGroup(this);3263 this.assetManager = new MoonbeamAssetManagerGroup(this);3264 this.assets = new AssetsGroup(this);3265 this.xTokens = new XTokensGroup(this);3266 this.democracy = new MoonbeamDemocracyGroup(this, options);3267 this.collective = {3268 council: new MoonbeamCollectiveGroup(this, 'councilCollective'),3269 techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),3270 };3271 }3272}32733274export class AstarHelper extends XcmChainHelper {3275 balance: SubstrateBalanceGroup<AstarHelper>;3276 assets: AssetsGroup<AstarHelper>;3277 xcm: XcmGroup<AstarHelper>;32783279 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3280 super(logger, options.helperBase ?? AstarHelper);32813282 this.balance = new SubstrateBalanceGroup(this);3283 this.assets = new AssetsGroup(this);3284 this.xcm = new XcmGroup(this, 'polkadotXcm');3285 }32863287 getSudo<T extends UniqueHelper>() {3288 // eslint-disable-next-line @typescript-eslint/naming-convention3289 const SudoHelperType = SudoHelper(this.helperBase);3290 return this.clone(SudoHelperType) as T;3291 }3292}32933294export class AcalaHelper extends XcmChainHelper {3295 balance: SubstrateBalanceGroup<AcalaHelper>;3296 assetRegistry: AcalaAssetRegistryGroup;3297 xTokens: XTokensGroup<AcalaHelper>;3298 tokens: TokensGroup<AcalaHelper>;3299 xcm: XcmGroup<AcalaHelper>;33003301 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3302 super(logger, options.helperBase ?? AcalaHelper);33033304 this.balance = new SubstrateBalanceGroup(this);3305 this.assetRegistry = new AcalaAssetRegistryGroup(this);3306 this.xTokens = new XTokensGroup(this);3307 this.tokens = new TokensGroup(this);3308 this.xcm = new XcmGroup(this, 'polkadotXcm');3309 }33103311 getSudo<T extends AcalaHelper>() {3312 // eslint-disable-next-line @typescript-eslint/naming-convention3313 const SudoHelperType = SudoHelper(this.helperBase);3314 return this.clone(SudoHelperType) as T;3315 }3316}33173318// eslint-disable-next-line @typescript-eslint/naming-convention3319function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {3320 return class extends Base {3321 scheduleFn: 'schedule' | 'scheduleAfter';3322 blocksNum: number;3323 options: ISchedulerOptions;33243325 constructor(...args: any[]) {3326 const logger = args[0] as ILogger;3327 const options = args[1] as {3328 scheduleFn: 'schedule' | 'scheduleAfter',3329 blocksNum: number,3330 options: ISchedulerOptions3331 };33323333 super(logger);33343335 this.scheduleFn = options.scheduleFn;3336 this.blocksNum = options.blocksNum;3337 this.options = options.options;3338 }33393340 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {3341 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);33423343 const mandatorySchedArgs = [3344 this.blocksNum,3345 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,3346 this.options.priority ?? null,3347 scheduledTx,3348 ];33493350 let schedArgs;3351 let scheduleFn;33523353 if (this.options.scheduledId) {3354 schedArgs = [this.options.scheduledId!, ...mandatorySchedArgs];33553356 if (this.scheduleFn == 'schedule') {3357 scheduleFn = 'scheduleNamed';3358 } else if (this.scheduleFn == 'scheduleAfter') {3359 scheduleFn = 'scheduleNamedAfter';3360 }3361 } else {3362 schedArgs = mandatorySchedArgs;3363 scheduleFn = this.scheduleFn;3364 }33653366 const extrinsic = 'api.tx.scheduler.' + scheduleFn;33673368 return super.executeExtrinsic(3369 sender,3370 extrinsic,3371 schedArgs,3372 expectSuccess,3373 );3374 }3375 };3376}33773378// eslint-disable-next-line @typescript-eslint/naming-convention3379function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {3380 return class extends Base {3381 constructor(...args: any[]) {3382 super(...args);3383 }33843385 async executeExtrinsic(3386 sender: IKeyringPair,3387 extrinsic: string,3388 params: any[],3389 expectSuccess?: boolean,3390 options: Partial<SignerOptions>|null = null,3391 ): Promise<ITransactionResult> {3392 const call = this.constructApiCall(extrinsic, params);3393 const result = await super.executeExtrinsic(3394 sender,3395 'api.tx.sudo.sudo',3396 [call],3397 expectSuccess,3398 options,3399 );34003401 if (result.status === 'Fail') return result;34023403 const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;3404 if (data.isErr) {3405 if (data.asErr.isModule) {3406 const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;3407 const metaError = super.getApi()?.registry.findMetaError(error);3408 throw new Error(`${metaError.section}.${metaError.name}`);3409 } else {3410 throw new Error(data.asErr.toHuman());3411 }3412 }3413 return result;3414 }3415 };3416}34173418export class UniqueBaseCollection {3419 helper: UniqueHelper;3420 collectionId: number;34213422 constructor(collectionId: number, uniqueHelper: UniqueHelper) {3423 this.collectionId = collectionId;3424 this.helper = uniqueHelper;3425 }34263427 async getData() {3428 return await this.helper.collection.getData(this.collectionId);3429 }34303431 async getLastTokenId() {3432 return await this.helper.collection.getLastTokenId(this.collectionId);3433 }34343435 async doesTokenExist(tokenId: number) {3436 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);3437 }34383439 async getAdmins() {3440 return await this.helper.collection.getAdmins(this.collectionId);3441 }34423443 async getAllowList() {3444 return await this.helper.collection.getAllowList(this.collectionId);3445 }34463447 async getEffectiveLimits() {3448 return await this.helper.collection.getEffectiveLimits(this.collectionId);3449 }34503451 async getProperties(propertyKeys?: string[] | null) {3452 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);3453 }34543455 async getPropertiesConsumedSpace() {3456 return await this.helper.collection.getPropertiesConsumedSpace(this.collectionId);3457 }34583459 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {3460 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);3461 }34623463 async getOptions() {3464 return await this.helper.collection.getCollectionOptions(this.collectionId);3465 }34663467 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {3468 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);3469 }34703471 async confirmSponsorship(signer: TSigner) {3472 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);3473 }34743475 async removeSponsor(signer: TSigner) {3476 return await this.helper.collection.removeSponsor(signer, this.collectionId);3477 }34783479 async setLimits(signer: TSigner, limits: ICollectionLimits) {3480 return await this.helper.collection.setLimits(signer, this.collectionId, limits);3481 }34823483 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {3484 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);3485 }34863487 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3488 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);3489 }34903491 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {3492 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);3493 }34943495 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {3496 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);3497 }34983499 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3500 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);3501 }35023503 async setProperties(signer: TSigner, properties: IProperty[]) {3504 return await this.helper.collection.setProperties(signer, this.collectionId, properties);3505 }35063507 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3508 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);3509 }35103511 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {3512 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);3513 }35143515 async enableNesting(signer: TSigner, permissions: INestingPermissions) {3516 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);3517 }35183519 async disableNesting(signer: TSigner) {3520 return await this.helper.collection.disableNesting(signer, this.collectionId);3521 }35223523 async burn(signer: TSigner) {3524 return await this.helper.collection.burn(signer, this.collectionId);3525 }35263527 scheduleAt<T extends UniqueHelper>(3528 executionBlockNumber: number,3529 options: ISchedulerOptions = {},3530 ) {3531 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3532 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3533 }35343535 scheduleAfter<T extends UniqueHelper>(3536 blocksBeforeExecution: number,3537 options: ISchedulerOptions = {},3538 ) {3539 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3540 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3541 }35423543 getSudo<T extends UniqueHelper>() {3544 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());3545 }3546}354735483549export class UniqueNFTCollection extends UniqueBaseCollection {3550 getTokenObject(tokenId: number) {3551 return new UniqueNFToken(tokenId, this);3552 }35533554 async getTokensByAddress(addressObj: ICrossAccountId) {3555 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);3556 }35573558 async getToken(tokenId: number, blockHashAt?: string) {3559 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);3560 }35613562 async getTokenOwner(tokenId: number, blockHashAt?: string) {3563 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3564 }35653566 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3567 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3568 }35693570 async getTokenChildren(tokenId: number, blockHashAt?: string) {3571 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);3572 }35733574 async getPropertyPermissions(propertyKeys: string[] | null = null) {3575 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);3576 }35773578 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3579 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3580 }35813582 async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3583 const api = this.helper.getApi();3584 const props = (await api.query.nonfungible.tokenProperties(this.collectionId, tokenId)).toJSON();35853586 return (props! as any).consumedSpace;3587 }35883589 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {3590 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);3591 }35923593 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3594 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);3595 }35963597 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {3598 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);3599 }36003601 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {3602 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);3603 }36043605 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3606 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});3607 }36083609 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {3610 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);3611 }36123613 async burnToken(signer: TSigner, tokenId: number) {3614 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);3615 }36163617 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {3618 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);3619 }36203621 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3622 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);3623 }36243625 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3626 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3627 }36283629 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3630 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3631 }36323633 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3634 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3635 }36363637 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3638 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3639 }36403641 scheduleAt<T extends UniqueHelper>(3642 executionBlockNumber: number,3643 options: ISchedulerOptions = {},3644 ) {3645 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3646 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3647 }36483649 scheduleAfter<T extends UniqueHelper>(3650 blocksBeforeExecution: number,3651 options: ISchedulerOptions = {},3652 ) {3653 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3654 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3655 }36563657 getSudo<T extends UniqueHelper>() {3658 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());3659 }3660}366136623663export class UniqueRFTCollection extends UniqueBaseCollection {3664 getTokenObject(tokenId: number) {3665 return new UniqueRFToken(tokenId, this);3666 }36673668 async getToken(tokenId: number, blockHashAt?: string) {3669 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);3670 }36713672 async getTokenOwner(tokenId: number, blockHashAt?: string) {3673 return await this.helper.rft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3674 }36753676 async getTokensByAddress(addressObj: ICrossAccountId) {3677 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);3678 }36793680 async getTop10TokenOwners(tokenId: number) {3681 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);3682 }36833684 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3685 return await this.helper.rft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3686 }36873688 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {3689 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3690 }36913692 async getTokenTotalPieces(tokenId: number) {3693 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3694 }36953696 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3697 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3698 }36993700 async getPropertyPermissions(propertyKeys: string[] | null = null) {3701 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3702 }37033704 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3705 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3706 }37073708 async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3709 const api = this.helper.getApi();3710 const props = (await api.query.refungible.tokenProperties(this.collectionId, tokenId)).toJSON();37113712 return (props! as any).consumedSpace;3713 }37143715 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3716 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3717 }37183719 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3720 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3721 }37223723 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3724 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3725 }37263727 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3728 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3729 }37303731 async mintToken(signer: TSigner, pieces = 1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3732 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3733 }37343735 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3736 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3737 }37383739 async burnToken(signer: TSigner, tokenId: number, amount=1n) {3740 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3741 }37423743 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {3744 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3745 }37463747 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3748 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3749 }37503751 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3752 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3753 }37543755 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3756 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3757 }37583759 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3760 return await this.helper.rft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3761 }37623763 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3764 return await this.helper.rft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3765 }37663767 scheduleAt<T extends UniqueHelper>(3768 executionBlockNumber: number,3769 options: ISchedulerOptions = {},3770 ) {3771 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3772 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3773 }37743775 scheduleAfter<T extends UniqueHelper>(3776 blocksBeforeExecution: number,3777 options: ISchedulerOptions = {},3778 ) {3779 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3780 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3781 }37823783 getSudo<T extends UniqueHelper>() {3784 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3785 }3786}378737883789export class UniqueFTCollection extends UniqueBaseCollection {3790 async getBalance(addressObj: ICrossAccountId) {3791 return await this.helper.ft.getBalance(this.collectionId, addressObj);3792 }37933794 async getTotalPieces() {3795 return await this.helper.ft.getTotalPieces(this.collectionId);3796 }37973798 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3799 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3800 }38013802 async getTop10Owners() {3803 return await this.helper.ft.getTop10Owners(this.collectionId);3804 }38053806 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3807 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3808 }38093810 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3811 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3812 }38133814 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3815 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3816 }38173818 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3819 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3820 }38213822 async burnTokens(signer: TSigner, amount=1n) {3823 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3824 }38253826 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3827 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3828 }38293830 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3831 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3832 }38333834 scheduleAt<T extends UniqueHelper>(3835 executionBlockNumber: number,3836 options: ISchedulerOptions = {},3837 ) {3838 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3839 return new UniqueFTCollection(this.collectionId, scheduledHelper);3840 }38413842 scheduleAfter<T extends UniqueHelper>(3843 blocksBeforeExecution: number,3844 options: ISchedulerOptions = {},3845 ) {3846 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3847 return new UniqueFTCollection(this.collectionId, scheduledHelper);3848 }38493850 getSudo<T extends UniqueHelper>() {3851 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3852 }3853}385438553856export class UniqueBaseToken {3857 collection: UniqueNFTCollection | UniqueRFTCollection;3858 collectionId: number;3859 tokenId: number;38603861 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3862 this.collection = collection;3863 this.collectionId = collection.collectionId;3864 this.tokenId = tokenId;3865 }38663867 async getNextSponsored(addressObj: ICrossAccountId) {3868 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3869 }38703871 async getProperties(propertyKeys?: string[] | null) {3872 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3873 }38743875 async getTokenPropertiesConsumedSpace() {3876 return await this.collection.getTokenPropertiesConsumedSpace(this.tokenId);3877 }38783879 async setProperties(signer: TSigner, properties: IProperty[]) {3880 return await this.collection.setTokenProperties(signer, this.tokenId, properties);3881 }38823883 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3884 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3885 }38863887 async doesExist() {3888 return await this.collection.doesTokenExist(this.tokenId);3889 }38903891 nestingAccount() {3892 return this.collection.helper.util.getTokenAccount(this);3893 }38943895 scheduleAt<T extends UniqueHelper>(3896 executionBlockNumber: number,3897 options: ISchedulerOptions = {},3898 ) {3899 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3900 return new UniqueBaseToken(this.tokenId, scheduledCollection);3901 }39023903 scheduleAfter<T extends UniqueHelper>(3904 blocksBeforeExecution: number,3905 options: ISchedulerOptions = {},3906 ) {3907 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3908 return new UniqueBaseToken(this.tokenId, scheduledCollection);3909 }39103911 getSudo<T extends UniqueHelper>() {3912 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3913 }3914}391539163917export class UniqueNFToken extends UniqueBaseToken {3918 collection: UniqueNFTCollection;39193920 constructor(tokenId: number, collection: UniqueNFTCollection) {3921 super(tokenId, collection);3922 this.collection = collection;3923 }39243925 async getData(blockHashAt?: string) {3926 return await this.collection.getToken(this.tokenId, blockHashAt);3927 }39283929 async getOwner(blockHashAt?: string) {3930 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3931 }39323933 async getTopmostOwner(blockHashAt?: string) {3934 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3935 }39363937 async getChildren(blockHashAt?: string) {3938 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3939 }39403941 async nest(signer: TSigner, toTokenObj: IToken) {3942 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3943 }39443945 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3946 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3947 }39483949 async transfer(signer: TSigner, addressObj: ICrossAccountId) {3950 return await this.collection.transferToken(signer, this.tokenId, addressObj);3951 }39523953 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3954 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3955 }39563957 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3958 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3959 }39603961 async isApproved(toAddressObj: ICrossAccountId) {3962 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3963 }39643965 async burn(signer: TSigner) {3966 return await this.collection.burnToken(signer, this.tokenId);3967 }39683969 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3970 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3971 }39723973 scheduleAt<T extends UniqueHelper>(3974 executionBlockNumber: number,3975 options: ISchedulerOptions = {},3976 ) {3977 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3978 return new UniqueNFToken(this.tokenId, scheduledCollection);3979 }39803981 scheduleAfter<T extends UniqueHelper>(3982 blocksBeforeExecution: number,3983 options: ISchedulerOptions = {},3984 ) {3985 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3986 return new UniqueNFToken(this.tokenId, scheduledCollection);3987 }39883989 getSudo<T extends UniqueHelper>() {3990 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3991 }3992}39933994export class UniqueRFToken extends UniqueBaseToken {3995 collection: UniqueRFTCollection;39963997 constructor(tokenId: number, collection: UniqueRFTCollection) {3998 super(tokenId, collection);3999 this.collection = collection;4000 }40014002 async getData(blockHashAt?: string) {4003 return await this.collection.getToken(this.tokenId, blockHashAt);4004 }40054006 async getOwner(blockHashAt?: string) {4007 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);4008 }40094010 async getTop10Owners() {4011 return await this.collection.getTop10TokenOwners(this.tokenId);4012 }40134014 async getTopmostOwner(blockHashAt?: string) {4015 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);4016 }40174018 async nest(signer: TSigner, toTokenObj: IToken) {4019 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);4020 }40214022 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {4023 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);4024 }40254026 async getBalance(addressObj: ICrossAccountId) {4027 return await this.collection.getTokenBalance(this.tokenId, addressObj);4028 }40294030 async getTotalPieces() {4031 return await this.collection.getTokenTotalPieces(this.tokenId);4032 }40334034 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {4035 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);4036 }40374038 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {4039 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);4040 }40414042 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {4043 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);4044 }40454046 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {4047 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);4048 }40494050 async repartition(signer: TSigner, amount: bigint) {4051 return await this.collection.repartitionToken(signer, this.tokenId, amount);4052 }40534054 async burn(signer: TSigner, amount=1n) {4055 return await this.collection.burnToken(signer, this.tokenId, amount);4056 }40574058 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {4059 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);4060 }40614062 scheduleAt<T extends UniqueHelper>(4063 executionBlockNumber: number,4064 options: ISchedulerOptions = {},4065 ) {4066 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);4067 return new UniqueRFToken(this.tokenId, scheduledCollection);4068 }40694070 scheduleAfter<T extends UniqueHelper>(4071 blocksBeforeExecution: number,4072 options: ISchedulerOptions = {},4073 ) {4074 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);4075 return new UniqueRFToken(this.tokenId, scheduledCollection);4076 }40774078 getSudo<T extends UniqueHelper>() {4079 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());4080 }4081}1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// SPDX-License-Identifier: Apache-2.034/* eslint-disable @typescript-eslint/no-var-requires */5/* eslint-disable function-call-argument-newline */6/* eslint-disable no-prototype-builtins */78import {ApiPromise, WsProvider, Keyring} from '@polkadot/api';9import {SignerOptions} from '@polkadot/api/types/submittable';10import {ApiInterfaceEvents} from '@polkadot/api/types';11import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm, base58Encode, blake2AsU8a} from '@polkadot/util-crypto';12import {IKeyringPair} from '@polkadot/types/types';13import {hexToU8a} from '@polkadot/util/hex';14import {u8aConcat} from '@polkadot/util/u8a';15import {16 IApiListeners,17 IBlock,18 IEvent,19 IChainProperties,20 ICollectionCreationOptions,21 ICollectionLimits,22 ICollectionPermissions,23 ICrossAccountId,24 ICrossAccountIdLower,25 ILogger,26 INestingPermissions,27 IProperty,28 IStakingInfo,29 ISchedulerOptions,30 ISubstrateBalance,31 IToken,32 ITokenPropertyPermission,33 ITransactionResult,34 IUniqueHelperLog,35 TApiAllowedListeners,36 TEthereumAccount,37 TSigner,38 TSubstrateAccount,39 TNetworks,40 IForeignAssetMetadata,41 AcalaAssetMetadata,42 MoonbeamAssetInfo,43 DemocracyStandardAccountVote,44 IEthCrossAccountId,45} from './types';46import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';47import type {Vec} from '@polkadot/types-codec';48import {FrameSystemEventRecord} from '@polkadot/types/lookup';4950export class CrossAccountId implements ICrossAccountId {51 Substrate?: TSubstrateAccount;52 Ethereum?: TEthereumAccount;5354 constructor(account: ICrossAccountId) {55 if (account.Substrate) this.Substrate = account.Substrate;56 if (account.Ethereum) this.Ethereum = account.Ethereum;57 }5859 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {60 switch (domain) {61 case 'Substrate': return new CrossAccountId({Substrate: account.address});62 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();63 }64 }6566 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {67 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});68 }6970 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {71 return encodeAddress(decodeAddress(address), ss58Format);72 }7374 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {75 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});76 }7778 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {79 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);80 return this;81 }8283 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {84 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));85 }8687 toEthereum(): CrossAccountId {88 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});89 return this;90 }9192 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {93 return evmToAddress(address, ss58Format);94 }9596 toSubstrate(ss58Format?: number): CrossAccountId {97 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});98 return this;99 }100101 toLowerCase(): CrossAccountId {102 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();103 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();104 return this;105 }106}107108const nesting = {109 toChecksumAddress(address: string): string {110 if (typeof address === 'undefined') return '';111112 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);113114 address = address.toLowerCase().replace(/^0x/i,'');115 const addressHash = keccakAsHex(address).replace(/^0x/i,'');116 const checksumAddress = ['0x'];117118 for (let i = 0; i < address.length; i++) {119 // If ith character is 8 to f then make it uppercase120 if (parseInt(addressHash[i], 16) > 7) {121 checksumAddress.push(address[i].toUpperCase());122 } else {123 checksumAddress.push(address[i]);124 }125 }126 return checksumAddress.join('');127 },128 tokenIdToAddress(collectionId: number, tokenId: number) {129 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8,'0')}${tokenId.toString(16).padStart(8,'0')}`);130 },131};132133class UniqueUtil {134 static transactionStatus = {135 NOT_READY: 'NotReady',136 FAIL: 'Fail',137 SUCCESS: 'Success',138 };139140 static chainLogType = {141 EXTRINSIC: 'extrinsic',142 RPC: 'rpc',143 };144145 static getTokenAccount(token: IToken): CrossAccountId {146 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});147 }148149 static getTokenAddress(token: IToken): string {150 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);151 }152153 static getDefaultLogger(): ILogger {154 return {155 log(msg: any, level = 'INFO') {156 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));157 },158 level: {159 ERROR: 'ERROR',160 WARNING: 'WARNING',161 INFO: 'INFO',162 },163 };164 }165166 static vec2str(arr: string[] | number[]) {167 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');168 }169170 static str2vec(string: string) {171 if (typeof string !== 'string') return string;172 return Array.from(string).map(x => x.charCodeAt(0));173 }174175 static fromSeed(seed: string, ss58Format = 42) {176 const keyring = new Keyring({type: 'sr25519', ss58Format});177 return keyring.addFromUri(seed);178 }179180 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {181 if (creationResult.status !== this.transactionStatus.SUCCESS) {182 throw Error('Unable to create collection!');183 }184185 let collectionId = null;186 creationResult.result.events.forEach(({event: {data, method, section}}) => {187 if ((section === 'common') && (method === 'CollectionCreated')) {188 collectionId = parseInt(data[0].toString(), 10);189 }190 });191192 if (collectionId === null) {193 throw Error('No CollectionCreated event was found!');194 }195196 return collectionId;197 }198199 static extractTokensFromCreationResult(creationResult: ITransactionResult): {200 success: boolean,201 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],202 } {203 if (creationResult.status !== this.transactionStatus.SUCCESS) {204 throw Error('Unable to create tokens!');205 }206 let success = false;207 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];208 creationResult.result.events.forEach(({event: {data, method, section}}) => {209 if (method === 'ExtrinsicSuccess') {210 success = true;211 } else if ((section === 'common') && (method === 'ItemCreated')) {212 tokens.push({213 collectionId: parseInt(data[0].toString(), 10),214 tokenId: parseInt(data[1].toString(), 10),215 owner: data[2].toHuman(),216 amount: data[3].toBigInt(),217 });218 }219 });220 return {success, tokens};221 }222223 static extractTokensFromBurnResult(burnResult: ITransactionResult): {224 success: boolean,225 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],226 } {227 if (burnResult.status !== this.transactionStatus.SUCCESS) {228 throw Error('Unable to burn tokens!');229 }230 let success = false;231 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];232 burnResult.result.events.forEach(({event: {data, method, section}}) => {233 if (method === 'ExtrinsicSuccess') {234 success = true;235 } else if ((section === 'common') && (method === 'ItemDestroyed')) {236 tokens.push({237 collectionId: parseInt(data[0].toString(), 10),238 tokenId: parseInt(data[1].toString(), 10),239 owner: data[2].toHuman(),240 amount: data[3].toBigInt(),241 });242 }243 });244 return {success, tokens};245 }246247 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {248 let eventId = null;249 events.forEach(({event: {data, method, section}}) => {250 if ((section === expectedSection) && (method === expectedMethod)) {251 eventId = parseInt(data[0].toString(), 10);252 }253 });254255 if (eventId === null) {256 throw Error(`No ${expectedMethod} event was found!`);257 }258 return eventId === collectionId;259 }260261 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {262 const normalizeAddress = (address: string | ICrossAccountId) => {263 if(typeof address === 'string') return address;264 const obj = {} as any;265 Object.keys(address).forEach(k => {266 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];267 });268 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);269 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();270 return address;271 };272 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;273 events.forEach(({event: {data, method, section}}) => {274 if ((section === 'common') && (method === 'Transfer')) {275 const hData = (data as any).toJSON();276 transfer = {277 collectionId: hData[0],278 tokenId: hData[1],279 from: normalizeAddress(hData[2]),280 to: normalizeAddress(hData[3]),281 amount: BigInt(hData[4]),282 };283 }284 });285 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;286 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);287 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);288 isSuccess = isSuccess && amount === transfer.amount;289 return isSuccess;290 }291292 static bigIntToDecimals(number: bigint, decimals = 18) {293 const numberStr = number.toString();294 const dotPos = numberStr.length - decimals;295296 if (dotPos <= 0) {297 return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;298 } else {299 const intPart = numberStr.substring(0, dotPos);300 const fractPart = numberStr.substring(dotPos);301 return intPart + '.' + fractPart;302 }303 }304}305306class UniqueEventHelper {307 private static extractIndex(index: any): [number, number] | string {308 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];309 return index.toJSON();310 }311312 private static extractSub(data: any, subTypes: any): {[key: string]: any} {313 let obj: any = {};314 let index = 0;315316 if (data.entries) {317 for(const [key, value] of data.entries()) {318 obj[key] = this.extractData(value, subTypes[index]);319 index++;320 }321 } else obj = data.toJSON();322323 return obj;324 }325326 private static toHuman(data: any) {327 return data && data.toHuman ? data.toHuman() : `${data}`;328 }329330 private static extractData(data: any, type: any): any {331 if(!type) return this.toHuman(data);332 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();333 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();334 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);335 return this.toHuman(data);336 }337338 public static extractEvents(events: {event: any, phase: any}[]): IEvent[] {339 const parsedEvents: IEvent[] = [];340341 events.forEach((record) => {342 const {event, phase} = record;343 const types = event.typeDef;344345 const eventData: IEvent = {346 section: event.section.toString(),347 method: event.method.toString(),348 index: this.extractIndex(event.index),349 data: [],350 phase: phase.toJSON(),351 };352353 event.data.forEach((val: any, index: number) => {354 eventData.data.push(this.extractData(val, types[index]));355 });356357 parsedEvents.push(eventData);358 });359360 return parsedEvents;361 }362}363364export class ChainHelperBase {365 helperBase: any;366367 transactionStatus = UniqueUtil.transactionStatus;368 chainLogType = UniqueUtil.chainLogType;369 util: typeof UniqueUtil;370 eventHelper: typeof UniqueEventHelper;371 logger: ILogger;372 api: ApiPromise | null;373 forcedNetwork: TNetworks | null;374 network: TNetworks | null;375 wsEndpoint: string | null;376 chainLog: IUniqueHelperLog[];377 children: ChainHelperBase[];378 address: AddressGroup;379 chain: ChainGroup;380381 constructor(logger?: ILogger, helperBase?: any) {382 this.helperBase = helperBase;383384 this.util = UniqueUtil;385 this.eventHelper = UniqueEventHelper;386 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();387 this.logger = logger;388 this.api = null;389 this.forcedNetwork = null;390 this.network = null;391 this.wsEndpoint = null;392 this.chainLog = [];393 this.children = [];394 this.address = new AddressGroup(this);395 this.chain = new ChainGroup(this);396 }397398 clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {399 Object.setPrototypeOf(helperCls.prototype, this);400 const newHelper = new helperCls(this.logger, options);401402 newHelper.api = this.api;403 newHelper.network = this.network;404 newHelper.forceNetwork = this.forceNetwork;405406 this.children.push(newHelper);407408 return newHelper;409 }410411 getEndpoint(): string {412 if (this.wsEndpoint === null) throw Error('No connection was established');413 return this.wsEndpoint;414 }415416 getApi(): ApiPromise {417 if(this.api === null) throw Error('API not initialized');418 return this.api;419 }420421 async subscribeEvents(expectedEvents: {section: string, names: string[]}[]) {422 const collectedEvents: IEvent[] = [];423 const unsubscribe = await this.getApi().query.system.events((events: Vec<FrameSystemEventRecord>) => {424 const ievents = this.eventHelper.extractEvents(events);425 ievents.forEach((event) => {426 expectedEvents.forEach((e => {427 if (event.section === e.section && e.names.includes(event.method)) {428 collectedEvents.push(event);429 }430 }));431 });432 });433 return {unsubscribe: unsubscribe as any, collectedEvents};434 }435436 clearChainLog(): void {437 this.chainLog = [];438 }439440 forceNetwork(value: TNetworks): void {441 this.forcedNetwork = value;442 }443444 async connect(wsEndpoint: string, listeners?: IApiListeners) {445 if (this.api !== null) throw Error('Already connected');446 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);447 this.wsEndpoint = wsEndpoint;448 this.api = api;449 this.network = network;450 }451452 async disconnect() {453 for (const child of this.children) {454 child.clearApi();455 }456457 if (this.api === null) return;458 await this.api.disconnect();459 this.clearApi();460 }461462 clearApi() {463 this.api = null;464 this.network = null;465 }466467 static async detectNetwork(api: ApiPromise): Promise<TNetworks> {468 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;469 const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];470471 if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;472473 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;474 return 'opal';475 }476477 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {478 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});479 await api.isReady;480481 const network = await this.detectNetwork(api);482483 await api.disconnect();484485 return network;486 }487488 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{489 api: ApiPromise;490 network: TNetworks;491 }> {492 if(typeof network === 'undefined' || network === null) network = 'opal';493 const supportedRPC = {494 opal: {495 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,496 },497 quartz: {498 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,499 },500 unique: {501 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,502 },503 rococo: {},504 westend: {},505 moonbeam: {},506 moonriver: {},507 acala: {},508 karura: {},509 westmint: {},510 };511 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);512 const rpc = supportedRPC[network];513514 // TODO: investigate how to replace rpc in runtime515 // api._rpcCore.addUserInterfaces(rpc);516517 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});518519 await api.isReadyOrError;520521 if (typeof listeners === 'undefined') listeners = {};522 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {523 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;524 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);525 }526527 return {api, network};528 }529530 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {531 const {events, status} = data;532 if (status.isReady) {533 return this.transactionStatus.NOT_READY;534 }535 if (status.isBroadcast) {536 return this.transactionStatus.NOT_READY;537 }538 if (status.isInBlock || status.isFinalized) {539 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');540 if (errors.length > 0) {541 return this.transactionStatus.FAIL;542 }543 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {544 return this.transactionStatus.SUCCESS;545 }546 }547548 return this.transactionStatus.FAIL;549 }550551 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {552 const sign = (callback: any) => {553 if(options !== null) return transaction.signAndSend(sender, options, callback);554 return transaction.signAndSend(sender, callback);555 };556 // eslint-disable-next-line no-async-promise-executor557 return new Promise(async (resolve, reject) => {558 try {559 const unsub = await sign((result: any) => {560 const status = this.getTransactionStatus(result);561562 if (status === this.transactionStatus.SUCCESS) {563 this.logger.log(`${label} successful`);564 unsub();565 resolve({result, status, blockHash: result.status.asInBlock.toHuman()});566 } else if (status === this.transactionStatus.FAIL) {567 let moduleError = null;568569 if (result.hasOwnProperty('dispatchError')) {570 const dispatchError = result['dispatchError'];571572 if (dispatchError) {573 if (dispatchError.isModule) {574 const modErr = dispatchError.asModule;575 const errorMeta = dispatchError.registry.findMetaError(modErr);576577 moduleError = `${errorMeta.section}.${errorMeta.name}`;578 } else {579 moduleError = dispatchError.toHuman();580 }581 } else {582 this.logger.log(result, this.logger.level.ERROR);583 }584 }585586 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);587 unsub();588 reject({status, moduleError, result});589 }590 });591 } catch (e) {592 this.logger.log(e, this.logger.level.ERROR);593 reject(e);594 }595 });596 }597598 async signTransactionWithoutSending(signer: TSigner, tx: any) {599 const api = this.getApi();600 const signingInfo = await api.derive.tx.signingInfo(signer.address);601602 tx.sign(signer, {603 blockHash: api.genesisHash,604 genesisHash: api.genesisHash,605 runtimeVersion: api.runtimeVersion,606 nonce: signingInfo.nonce,607 });608609 return tx.toHex();610 }611612 async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {613 const api = this.getApi();614 const signingInfo = await api.derive.tx.signingInfo(signer.address);615616 // We need to sign the tx because617 // unsigned transactions does not have an inclusion fee618 tx.sign(signer, {619 blockHash: api.genesisHash,620 genesisHash: api.genesisHash,621 runtimeVersion: api.runtimeVersion,622 nonce: signingInfo.nonce,623 });624625 if (len === null) {626 return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;627 } else {628 return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;629 }630 }631632 constructApiCall(apiCall: string, params: any[]) {633 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);634 let call = this.getApi() as any;635 for(const part of apiCall.slice(4).split('.')) {636 call = call[part];637 if (!call) {638 const advice = part.includes('_') ? ' Looks like it needs to be converted to camel case.' : '';639 throw Error(`Function ${part} of api call ${apiCall} not found.${advice}`);640 }641 }642 return call(...params);643 }644645 encodeApiCall(apiCall: string, params: any[]) {646 return this.constructApiCall(apiCall, params).method.toHex();647 }648649 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {650 if(this.api === null) throw Error('API not initialized');651 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);652653 const startTime = (new Date()).getTime();654 let result: ITransactionResult;655 let events: IEvent[] = [];656 try {657 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;658 events = this.eventHelper.extractEvents(result.result.events);659 const errorEvent = events.find((event) => event.method == 'ExecutedFailed' || event.method == 'CreatedFailed');660 if (errorEvent)661 throw Error(errorEvent.method + ': ' + extrinsic);662 }663 catch(e) {664 if(!(e as object).hasOwnProperty('status')) throw e;665 result = e as ITransactionResult;666 }667668 const endTime = (new Date()).getTime();669670 const log = {671 executedAt: endTime,672 executionTime: endTime - startTime,673 type: this.chainLogType.EXTRINSIC,674 status: result.status,675 call: extrinsic,676 signer: this.getSignerAddress(sender),677 params,678 } as IUniqueHelperLog;679680 let errorMessage = '';681682 if(result.status !== this.transactionStatus.SUCCESS) {683 if (result.moduleError) {684 errorMessage = typeof result.moduleError === 'string'685 ? result.moduleError686 : `${Object.keys(result.moduleError)[0]}: ${Object.values(result.moduleError)[0]}`;687 log.moduleError = errorMessage;688 }689 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;690 }691 if(events.length > 0) log.events = events;692693 this.chainLog.push(log);694695 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {696 if (result.moduleError) throw Error(`${errorMessage}`);697 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));698 }699 return result;700 }701702 async callRpc(rpc: string, params?: any[]) {703 if(typeof params === 'undefined') params = [];704 if(this.api === null) throw Error('API not initialized');705 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);706707 const startTime = (new Date()).getTime();708 let result;709 let error = null;710 const log = {711 type: this.chainLogType.RPC,712 call: rpc,713 params,714 } as IUniqueHelperLog;715716 try {717 result = await this.constructApiCall(rpc, params);718 }719 catch(e) {720 error = e;721 }722723 const endTime = (new Date()).getTime();724725 log.executedAt = endTime;726 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';727 log.executionTime = endTime - startTime;728729 this.chainLog.push(log);730731 if(error !== null) throw error;732733 return result;734 }735736 getSignerAddress(signer: IKeyringPair | string): string {737 if(typeof signer === 'string') return signer;738 return signer.address;739 }740741 fetchAllPalletNames(): string[] {742 if(this.api === null) throw Error('API not initialized');743 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase()).sort();744 }745746 fetchMissingPalletNames(requiredPallets: string[]): string[] {747 const palletNames = this.fetchAllPalletNames();748 return requiredPallets.filter(p => !palletNames.includes(p));749 }750}751752753class HelperGroup<T extends ChainHelperBase> {754 helper: T;755756 constructor(uniqueHelper: T) {757 this.helper = uniqueHelper;758 }759}760761762class CollectionGroup extends HelperGroup<UniqueHelper> {763 /**764 * Get number of blocks when sponsored transaction is available.765 *766 * @param collectionId ID of collection767 * @param tokenId ID of token768 * @param addressObj address for which the sponsorship is checked769 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});770 * @returns number of blocks or null if sponsorship hasn't been set771 */772 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {773 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();774 }775776 /**777 * Get the number of created collections.778 *779 * @returns number of created collections780 */781 async getTotalCount(): Promise<number> {782 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();783 }784785 /**786 * Get information about the collection with additional data,787 * including the number of tokens it contains, its administrators,788 * the normalized address of the collection's owner, and decoded name and description.789 *790 * @param collectionId ID of collection791 * @example await getData(2)792 * @returns collection information object793 */794 async getData(collectionId: number): Promise<{795 id: number;796 name: string;797 description: string;798 tokensCount: number;799 admins: CrossAccountId[];800 normalizedOwner: TSubstrateAccount;801 raw: any802 } | null> {803 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);804 const humanCollection = collection.toHuman(), collectionData = {805 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],806 raw: humanCollection,807 } as any, jsonCollection = collection.toJSON();808 if (humanCollection === null) return null;809 collectionData.raw.limits = jsonCollection.limits;810 collectionData.raw.permissions = jsonCollection.permissions;811 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);812 for (const key of ['name', 'description']) {813 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);814 }815816 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))817 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)818 : 0;819 collectionData.admins = await this.getAdmins(collectionId);820821 return collectionData;822 }823824 /**825 * Get the addresses of the collection's administrators, optionally normalized.826 *827 * @param collectionId ID of collection828 * @param normalize whether to normalize the addresses to the default ss58 format829 * @example await getAdmins(1)830 * @returns array of administrators831 */832 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {833 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();834835 return normalize836 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())837 : admins;838 }839840 /**841 * Get the addresses added to the collection allow-list, optionally normalized.842 * @param collectionId ID of collection843 * @param normalize whether to normalize the addresses to the default ss58 format844 * @example await getAllowList(1)845 * @returns array of allow-listed addresses846 */847 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {848 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();849 return normalize850 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())851 : allowListed;852 }853854 /**855 * Get the effective limits of the collection instead of null for default values856 *857 * @param collectionId ID of collection858 * @example await getEffectiveLimits(2)859 * @returns object of collection limits860 */861 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {862 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();863 }864865 /**866 * Burns the collection if the signer has sufficient permissions and collection is empty.867 *868 * @param signer keyring of signer869 * @param collectionId ID of collection870 * @example await helper.collection.burn(aliceKeyring, 3);871 * @returns ```true``` if extrinsic success, otherwise ```false```872 */873 async burn(signer: TSigner, collectionId: number): Promise<boolean> {874 const result = await this.helper.executeExtrinsic(875 signer,876 'api.tx.unique.destroyCollection', [collectionId],877 true,878 );879880 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');881 }882883 /**884 * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.885 *886 * @param signer keyring of signer887 * @param collectionId ID of collection888 * @param sponsorAddress Sponsor substrate address889 * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")890 * @returns ```true``` if extrinsic success, otherwise ```false```891 */892 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {893 const result = await this.helper.executeExtrinsic(894 signer,895 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],896 true,897 );898899 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorSet');900 }901902 /**903 * Confirms consent to sponsor the collection on behalf of the signer.904 *905 * @param signer keyring of signer906 * @param collectionId ID of collection907 * @example confirmSponsorship(aliceKeyring, 10)908 * @returns ```true``` if extrinsic success, otherwise ```false```909 */910 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {911 const result = await this.helper.executeExtrinsic(912 signer,913 'api.tx.unique.confirmSponsorship', [collectionId],914 true,915 );916917 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'SponsorshipConfirmed');918 }919920 /**921 * Removes the sponsor of a collection, regardless if it consented or not.922 *923 * @param signer keyring of signer924 * @param collectionId ID of collection925 * @example removeSponsor(aliceKeyring, 10)926 * @returns ```true``` if extrinsic success, otherwise ```false```927 */928 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {929 const result = await this.helper.executeExtrinsic(930 signer,931 'api.tx.unique.removeCollectionSponsor', [collectionId],932 true,933 );934935 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorRemoved');936 }937938 /**939 * Sets the limits of the collection. At least one limit must be specified for a correct call.940 *941 * @param signer keyring of signer942 * @param collectionId ID of collection943 * @param limits collection limits object944 * @example945 * await setLimits(946 * aliceKeyring,947 * 10,948 * {949 * sponsorTransferTimeout: 0,950 * ownerCanDestroy: false951 * }952 * )953 * @returns ```true``` if extrinsic success, otherwise ```false```954 */955 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {956 const result = await this.helper.executeExtrinsic(957 signer,958 'api.tx.unique.setCollectionLimits', [collectionId, limits],959 true,960 );961962 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionLimitSet');963 }964965 /**966 * Changes the owner of the collection to the new Substrate address.967 *968 * @param signer keyring of signer969 * @param collectionId ID of collection970 * @param ownerAddress substrate address of new owner971 * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")972 * @returns ```true``` if extrinsic success, otherwise ```false```973 */974 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {975 const result = await this.helper.executeExtrinsic(976 signer,977 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],978 true,979 );980981 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionOwnerChanged');982 }983984 /**985 * Adds a collection administrator.986 *987 * @param signer keyring of signer988 * @param collectionId ID of collection989 * @param adminAddressObj Administrator address (substrate or ethereum)990 * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})991 * @returns ```true``` if extrinsic success, otherwise ```false```992 */993 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {994 const result = await this.helper.executeExtrinsic(995 signer,996 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],997 true,998 );9991000 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminAdded');1001 }10021003 /**1004 * Removes a collection administrator.1005 *1006 * @param signer keyring of signer1007 * @param collectionId ID of collection1008 * @param adminAddressObj Administrator address (substrate or ethereum)1009 * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})1010 * @returns ```true``` if extrinsic success, otherwise ```false```1011 */1012 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {1013 const result = await this.helper.executeExtrinsic(1014 signer,1015 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],1016 true,1017 );10181019 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminRemoved');1020 }10211022 /**1023 * Check if user is in allow list.1024 *1025 * @param collectionId ID of collection1026 * @param user Account to check1027 * @example await getAdmins(1)1028 * @returns is user in allow list1029 */1030 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {1031 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();1032 }10331034 /**1035 * Adds an address to allow list1036 * @param signer keyring of signer1037 * @param collectionId ID of collection1038 * @param addressObj address to add to the allow list1039 * @returns ```true``` if extrinsic success, otherwise ```false```1040 */1041 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1042 const result = await this.helper.executeExtrinsic(1043 signer,1044 'api.tx.unique.addToAllowList', [collectionId, addressObj],1045 true,1046 );10471048 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressAdded');1049 }10501051 /**1052 * Removes an address from allow list1053 *1054 * @param signer keyring of signer1055 * @param collectionId ID of collection1056 * @param addressObj address to remove from the allow list1057 * @returns ```true``` if extrinsic success, otherwise ```false```1058 */1059 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1060 const result = await this.helper.executeExtrinsic(1061 signer,1062 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],1063 true,1064 );10651066 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressRemoved');1067 }10681069 /**1070 * Sets onchain permissions for selected collection.1071 *1072 * @param signer keyring of signer1073 * @param collectionId ID of collection1074 * @param permissions collection permissions object1075 * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});1076 * @returns ```true``` if extrinsic success, otherwise ```false```1077 */1078 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {1079 const result = await this.helper.executeExtrinsic(1080 signer,1081 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],1082 true,1083 );10841085 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPermissionSet');1086 }10871088 /**1089 * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.1090 *1091 * @param signer keyring of signer1092 * @param collectionId ID of collection1093 * @param permissions nesting permissions object1094 * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});1095 * @returns ```true``` if extrinsic success, otherwise ```false```1096 */1097 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1098 return await this.setPermissions(signer, collectionId, {nesting: permissions});1099 }11001101 /**1102 * Disables nesting for selected collection.1103 *1104 * @param signer keyring of signer1105 * @param collectionId ID of collection1106 * @example disableNesting(aliceKeyring, 10);1107 * @returns ```true``` if extrinsic success, otherwise ```false```1108 */1109 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1110 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1111 }11121113 /**1114 * Sets onchain properties to the collection.1115 *1116 * @param signer keyring of signer1117 * @param collectionId ID of collection1118 * @param properties array of property objects1119 * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);1120 * @returns ```true``` if extrinsic success, otherwise ```false```1121 */1122 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1123 const result = await this.helper.executeExtrinsic(1124 signer,1125 'api.tx.unique.setCollectionProperties', [collectionId, properties],1126 true,1127 );11281129 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1130 }11311132 /**1133 * Get collection properties.1134 *1135 * @param collectionId ID of collection1136 * @param propertyKeys optionally filter the returned properties to only these keys1137 * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1138 * @returns array of key-value pairs1139 */1140 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1141 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1142 }11431144 async getPropertiesConsumedSpace(collectionId: number): Promise<number> {1145 const api = this.helper.getApi();1146 const props = (await api.query.common.collectionProperties(collectionId)).toJSON();11471148 return (props! as any).consumedSpace;1149 }11501151 async getCollectionOptions(collectionId: number) {1152 return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1153 }11541155 /**1156 * Deletes onchain properties from the collection.1157 *1158 * @param signer keyring of signer1159 * @param collectionId ID of collection1160 * @param propertyKeys array of property keys to delete1161 * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1162 * @returns ```true``` if extrinsic success, otherwise ```false```1163 */1164 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1165 const result = await this.helper.executeExtrinsic(1166 signer,1167 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1168 true,1169 );11701171 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1172 }11731174 /**1175 * Changes the owner of the token.1176 *1177 * @param signer keyring of signer1178 * @param collectionId ID of collection1179 * @param tokenId ID of token1180 * @param addressObj address of a new owner1181 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1182 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1183 * @returns true if the token success, otherwise false1184 */1185 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1186 const result = await this.helper.executeExtrinsic(1187 signer,1188 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1189 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1190 );11911192 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1193 }11941195 /**1196 *1197 * Change ownership of a token(s) on behalf of the owner.1198 *1199 * @param signer keyring of signer1200 * @param collectionId ID of collection1201 * @param tokenId ID of token1202 * @param fromAddressObj address on behalf of which the token will be sent1203 * @param toAddressObj new token owner1204 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1205 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1206 * @returns true if the token success, otherwise false1207 */1208 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1209 const result = await this.helper.executeExtrinsic(1210 signer,1211 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1212 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1213 );1214 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1215 }12161217 /**1218 *1219 * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1220 *1221 * @param signer keyring of signer1222 * @param collectionId ID of collection1223 * @param tokenId ID of token1224 * @param amount amount of tokens to be burned. For NFT must be set to 1n1225 * @example burnToken(aliceKeyring, 10, 5);1226 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1227 */1228 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1229 const burnResult = await this.helper.executeExtrinsic(1230 signer,1231 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1232 true, // `Unable to burn token for ${label}`,1233 );1234 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1235 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1236 return burnedTokens.success;1237 }12381239 /**1240 * Destroys a concrete instance of NFT on behalf of the owner1241 *1242 * @param signer keyring of signer1243 * @param collectionId ID of collection1244 * @param tokenId ID of token1245 * @param fromAddressObj address on behalf of which the token will be burnt1246 * @param amount amount of tokens to be burned. For NFT must be set to 1n1247 * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1248 * @returns ```true``` if extrinsic success, otherwise ```false```1249 */1250 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1251 const burnResult = await this.helper.executeExtrinsic(1252 signer,1253 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1254 true, // `Unable to burn token from for ${label}`,1255 );1256 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1257 return burnedTokens.success && burnedTokens.tokens.length > 0;1258 }12591260 /**1261 * Set, change, or remove approved address to transfer the ownership of the NFT.1262 *1263 * @param signer keyring of signer1264 * @param collectionId ID of collection1265 * @param tokenId ID of token1266 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1267 * @param amount amount of token to be approved. For NFT must be set to 1n1268 * @returns ```true``` if extrinsic success, otherwise ```false```1269 */1270 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1271 const approveResult = await this.helper.executeExtrinsic(1272 signer,1273 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1274 true, // `Unable to approve token for ${label}`,1275 );12761277 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1278 }12791280 /**1281 * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1282 *1283 * @param signer keyring of signer1284 * @param collectionId ID of collection1285 * @param tokenId ID of token1286 * @param fromAddressObj Signer's Ethereum address containing her tokens1287 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1288 * @param amount amount of token to be approved. For NFT must be set to 1n1289 * @returns ```true``` if extrinsic success, otherwise ```false```1290 */1291 async approveTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1292 const approveResult = await this.helper.executeExtrinsic(1293 signer,1294 'api.tx.unique.approveFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1295 true, // `Unable to approve token for ${label}`,1296 );12971298 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1299 }13001301 /**1302 * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1303 *1304 * @param signer keyring of signer1305 * @param collectionId ID of collection1306 * @param tokenId ID of token1307 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1308 * @param amount amount of token to be approved. For NFT must be set to 1n1309 * @returns ```true``` if extrinsic success, otherwise ```false```1310 */1311 async approveTokenFromEth(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1312 const ethMirror = CrossAccountId.fromKeyring(signer).toEthereum();1313 return await this.approveTokenFrom(signer, collectionId, tokenId, ethMirror, toAddressObj, amount);1314 }13151316 /**1317 * Get the amount of token pieces approved to transfer or burn. Normally 0.1318 *1319 * @param collectionId ID of collection1320 * @param tokenId ID of token1321 * @param toAccountObj address which is approved to use token pieces1322 * @param fromAccountObj address which may have allowed the use of its owned tokens1323 * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1324 * @returns number of approved to transfer pieces1325 */1326 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1327 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1328 }13291330 /**1331 * Get the last created token ID in a collection1332 *1333 * @param collectionId ID of collection1334 * @example getLastTokenId(10);1335 * @returns id of the last created token1336 */1337 async getLastTokenId(collectionId: number): Promise<number> {1338 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1339 }13401341 /**1342 * Check if token exists1343 *1344 * @param collectionId ID of collection1345 * @param tokenId ID of token1346 * @example doesTokenExist(10, 20);1347 * @returns true if the token exists, otherwise false1348 */1349 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1350 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1351 }1352}13531354class NFTnRFT extends CollectionGroup {1355 /**1356 * Get tokens owned by account1357 *1358 * @param collectionId ID of collection1359 * @param addressObj tokens owner1360 * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1361 * @returns array of token ids owned by account1362 */1363 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1364 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1365 }13661367 /**1368 * Get token data1369 *1370 * @param collectionId ID of collection1371 * @param tokenId ID of token1372 * @param propertyKeys optionally filter the token properties to only these keys1373 * @param blockHashAt optionally query the data at some block with this hash1374 * @example getToken(10, 5);1375 * @returns human readable token data1376 */1377 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1378 properties: IProperty[];1379 owner: CrossAccountId;1380 normalizedOwner: CrossAccountId;1381 }| null> {1382 let tokenData;1383 if(typeof blockHashAt === 'undefined') {1384 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1385 }1386 else {1387 if(propertyKeys.length == 0) {1388 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1389 if(!collection) return null;1390 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1391 }1392 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1393 }1394 tokenData = tokenData.toHuman();1395 if (tokenData === null || tokenData.owner === null) return null;1396 const owner = {} as any;1397 for (const key of Object.keys(tokenData.owner)) {1398 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'1399 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])1400 : tokenData.owner[key];1401 }1402 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1403 return tokenData;1404 }14051406 /**1407 * Get token's owner1408 * @param collectionId ID of collection1409 * @param tokenId ID of token1410 * @param blockHashAt optionally query the data at the block with this hash1411 * @example getTokenOwner(10, 5);1412 * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1413 */1414 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1415 let owner;1416 if (typeof blockHashAt === 'undefined') {1417 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1418 } else {1419 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1420 }1421 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1422 }14231424 /**1425 * Recursively find the address that owns the token1426 * @param collectionId ID of collection1427 * @param tokenId ID of token1428 * @param blockHashAt1429 * @example getTokenTopmostOwner(10, 5);1430 * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1431 */1432 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1433 let owner;1434 if (typeof blockHashAt === 'undefined') {1435 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1436 } else {1437 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1438 }14391440 if (owner === null) return null;14411442 return owner.toHuman();1443 }14441445 /**1446 * Nest one token into another1447 * @param signer keyring of signer1448 * @param tokenObj token to be nested1449 * @param rootTokenObj token to be parent1450 * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1451 * @returns ```true``` if extrinsic success, otherwise ```false```1452 */1453 async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1454 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1455 const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1456 if(!result) {1457 throw Error('Unable to nest token!');1458 }1459 return result;1460 }14611462 /**1463 * Remove token from nested state1464 * @param signer keyring of signer1465 * @param tokenObj token to unnest1466 * @param rootTokenObj parent of a token1467 * @param toAddressObj address of a new token owner1468 * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1469 * @returns ```true``` if extrinsic success, otherwise ```false```1470 */1471 async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1472 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1473 const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1474 if(!result) {1475 throw Error('Unable to unnest token!');1476 }1477 return result;1478 }14791480 /**1481 * Set permissions to change token properties1482 *1483 * @param signer keyring of signer1484 * @param collectionId ID of collection1485 * @param permissions permissions to change a property by the collection admin or token owner1486 * @example setTokenPropertyPermissions(1487 * aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1488 * )1489 * @returns true if extrinsic success otherwise false1490 */1491 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1492 const result = await this.helper.executeExtrinsic(1493 signer,1494 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1495 true,1496 );14971498 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1499 }15001501 /**1502 * Get token property permissions.1503 *1504 * @param collectionId ID of collection1505 * @param propertyKeys optionally filter the returned property permissions to only these keys1506 * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1507 * @returns array of key-permission pairs1508 */1509 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1510 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1511 }15121513 /**1514 * Set token properties1515 *1516 * @param signer keyring of signer1517 * @param collectionId ID of collection1518 * @param tokenId ID of token1519 * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1520 * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1521 * @returns ```true``` if extrinsic success, otherwise ```false```1522 */1523 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1524 const result = await this.helper.executeExtrinsic(1525 signer,1526 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1527 true,1528 );15291530 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1531 }15321533 /**1534 * Get properties, metadata assigned to a token.1535 *1536 * @param collectionId ID of collection1537 * @param tokenId ID of token1538 * @param propertyKeys optionally filter the returned properties to only these keys1539 * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1540 * @returns array of key-value pairs1541 */1542 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1543 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1544 }15451546 /**1547 * Delete the provided properties of a token1548 * @param signer keyring of signer1549 * @param collectionId ID of collection1550 * @param tokenId ID of token1551 * @param propertyKeys property keys to be deleted1552 * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1553 * @returns ```true``` if extrinsic success, otherwise ```false```1554 */1555 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1556 const result = await this.helper.executeExtrinsic(1557 signer,1558 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1559 true,1560 );15611562 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1563 }15641565 /**1566 * Mint new collection1567 *1568 * @param signer keyring of signer1569 * @param collectionOptions basic collection options and properties1570 * @param mode NFT or RFT type of a collection1571 * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1572 * @returns object of the created collection1573 */1574 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1575 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1576 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1577 for (const key of ['name', 'description', 'tokenPrefix']) {1578 if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);1579 }1580 const creationResult = await this.helper.executeExtrinsic(1581 signer,1582 'api.tx.unique.createCollectionEx', [collectionOptions],1583 true, // errorLabel,1584 );1585 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1586 }15871588 getCollectionObject(_collectionId: number): any {1589 return null;1590 }15911592 getTokenObject(_collectionId: number, _tokenId: number): any {1593 return null;1594 }15951596 /**1597 * Tells whether the given `owner` approves the `operator`.1598 * @param collectionId ID of collection1599 * @param owner owner address1600 * @param operator operator addrees1601 * @returns true if operator is enabled1602 */1603 async allowanceForAll(collectionId: number, owner: ICrossAccountId, operator: ICrossAccountId): Promise<boolean> {1604 return (await this.helper.callRpc('api.rpc.unique.allowanceForAll', [collectionId, owner, operator])).toJSON();1605 }16061607 /** Sets or unsets the approval of a given operator.1608 * The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1609 * @param operator Operator1610 * @param approved Should operator status be granted or revoked?1611 * @returns ```true``` if extrinsic success, otherwise ```false```1612 */1613 async setAllowanceForAll(signer: TSigner, collectionId: number, operator: ICrossAccountId, approved: boolean): Promise<boolean> {1614 const result = await this.helper.executeExtrinsic(1615 signer,1616 'api.tx.unique.setAllowanceForAll', [collectionId, operator, approved],1617 true,1618 );1619 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'ApprovedForAll');1620 }1621}162216231624class NFTGroup extends NFTnRFT {1625 /**1626 * Get collection object1627 * @param collectionId ID of collection1628 * @example getCollectionObject(2);1629 * @returns instance of UniqueNFTCollection1630 */1631 getCollectionObject(collectionId: number): UniqueNFTCollection {1632 return new UniqueNFTCollection(collectionId, this.helper);1633 }16341635 /**1636 * Get token object1637 * @param collectionId ID of collection1638 * @param tokenId ID of token1639 * @example getTokenObject(10, 5);1640 * @returns instance of UniqueNFTToken1641 */1642 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1643 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1644 }16451646 /**1647 * Is token approved to transfer1648 * @param collectionId ID of collection1649 * @param tokenId ID of token1650 * @param toAccountObj address to be approved1651 * @returns ```true``` if extrinsic success, otherwise ```false```1652 */1653 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1654 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1655 }16561657 /**1658 * Changes the owner of the token.1659 *1660 * @param signer keyring of signer1661 * @param collectionId ID of collection1662 * @param tokenId ID of token1663 * @param addressObj address of a new owner1664 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1665 * @returns ```true``` if extrinsic success, otherwise ```false```1666 */1667 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1668 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1669 }16701671 /**1672 *1673 * Change ownership of a NFT on behalf of the owner.1674 *1675 * @param signer keyring of signer1676 * @param collectionId ID of collection1677 * @param tokenId ID of token1678 * @param fromAddressObj address on behalf of which the token will be sent1679 * @param toAddressObj new token owner1680 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1681 * @returns ```true``` if extrinsic success, otherwise ```false```1682 */1683 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1684 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1685 }16861687 /**1688 * Get tokens nested in the provided token1689 * @param collectionId ID of collection1690 * @param tokenId ID of token1691 * @param blockHashAt optionally query the data at the block with this hash1692 * @example getTokenChildren(10, 5);1693 * @returns tokens whose depth of nesting is <= 51694 */1695 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1696 let children;1697 if(typeof blockHashAt === 'undefined') {1698 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1699 } else {1700 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1701 }17021703 return children.toJSON().map((x: any) => {1704 return {collectionId: x.collection, tokenId: x.token};1705 });1706 }17071708 /**1709 * Mint new collection1710 * @param signer keyring of signer1711 * @param collectionOptions Collection options1712 * @example1713 * mintCollection(aliceKeyring, {1714 * name: 'New',1715 * description: 'New collection',1716 * tokenPrefix: 'NEW',1717 * })1718 * @returns object of the created collection1719 */1720 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1721 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1722 }17231724 /**1725 * Mint new token1726 * @param signer keyring of signer1727 * @param data token data1728 * @returns created token object1729 */1730 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1731 const creationResult = await this.helper.executeExtrinsic(1732 signer,1733 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1734 nft: {1735 properties: data.properties,1736 },1737 }],1738 true,1739 );1740 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1741 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1742 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1743 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1744 }17451746 /**1747 * Mint multiple NFT tokens1748 * @param signer keyring of signer1749 * @param collectionId ID of collection1750 * @param tokens array of tokens with owner and properties1751 * @example1752 * mintMultipleTokens(aliceKeyring, 10, [{1753 * owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1754 * properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1755 * },{1756 * owner: {Ethereum: "0x9F0583DbB855d..."},1757 * properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1758 * }]);1759 * @returns ```true``` if extrinsic success, otherwise ```false```1760 */1761 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1762 const creationResult = await this.helper.executeExtrinsic(1763 signer,1764 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1765 true,1766 );1767 const collection = this.getCollectionObject(collectionId);1768 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1769 }17701771 /**1772 * Mint multiple NFT tokens with one owner1773 * @param signer keyring of signer1774 * @param collectionId ID of collection1775 * @param owner tokens owner1776 * @param tokens array of tokens with owner and properties1777 * @example1778 * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1779 * properties: [{1780 * key: "gender",1781 * value: "female",1782 * },{1783 * key: "age",1784 * value: "33",1785 * }],1786 * }]);1787 * @returns array of newly created tokens1788 */1789 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1790 const rawTokens = [];1791 for (const token of tokens) {1792 const raw = {NFT: {properties: token.properties}};1793 rawTokens.push(raw);1794 }1795 const creationResult = await this.helper.executeExtrinsic(1796 signer,1797 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1798 true,1799 );1800 const collection = this.getCollectionObject(collectionId);1801 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1802 }18031804 /**1805 * Set, change, or remove approved address to transfer the ownership of the NFT.1806 *1807 * @param signer keyring of signer1808 * @param collectionId ID of collection1809 * @param tokenId ID of token1810 * @param toAddressObj address to approve1811 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1812 * @returns ```true``` if extrinsic success, otherwise ```false```1813 */1814 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1815 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1816 }1817}181818191820class RFTGroup extends NFTnRFT {1821 /**1822 * Get collection object1823 * @param collectionId ID of collection1824 * @example getCollectionObject(2);1825 * @returns instance of UniqueRFTCollection1826 */1827 getCollectionObject(collectionId: number): UniqueRFTCollection {1828 return new UniqueRFTCollection(collectionId, this.helper);1829 }18301831 /**1832 * Get token object1833 * @param collectionId ID of collection1834 * @param tokenId ID of token1835 * @example getTokenObject(10, 5);1836 * @returns instance of UniqueNFTToken1837 */1838 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1839 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1840 }18411842 /**1843 * Get top 10 token owners with the largest number of pieces1844 * @param collectionId ID of collection1845 * @param tokenId ID of token1846 * @example getTokenTop10Owners(10, 5);1847 * @returns array of top 10 owners1848 */1849 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1850 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1851 }18521853 /**1854 * Get number of pieces owned by address1855 * @param collectionId ID of collection1856 * @param tokenId ID of token1857 * @param addressObj address token owner1858 * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1859 * @returns number of pieces ownerd by address1860 */1861 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1862 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1863 }18641865 /**1866 * Transfer pieces of token to another address1867 * @param signer keyring of signer1868 * @param collectionId ID of collection1869 * @param tokenId ID of token1870 * @param addressObj address of a new owner1871 * @param amount number of pieces to be transfered1872 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1873 * @returns ```true``` if extrinsic success, otherwise ```false```1874 */1875 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1876 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1877 }18781879 /**1880 * Change ownership of some pieces of RFT on behalf of the owner.1881 * @param signer keyring of signer1882 * @param collectionId ID of collection1883 * @param tokenId ID of token1884 * @param fromAddressObj address on behalf of which the token will be sent1885 * @param toAddressObj new token owner1886 * @param amount number of pieces to be transfered1887 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1888 * @returns ```true``` if extrinsic success, otherwise ```false```1889 */1890 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1891 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1892 }18931894 /**1895 * Mint new collection1896 * @param signer keyring of signer1897 * @param collectionOptions Collection options1898 * @example1899 * mintCollection(aliceKeyring, {1900 * name: 'New',1901 * description: 'New collection',1902 * tokenPrefix: 'NEW',1903 * })1904 * @returns object of the created collection1905 */1906 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1907 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1908 }19091910 /**1911 * Mint new token1912 * @param signer keyring of signer1913 * @param data token data1914 * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1915 * @returns created token object1916 */1917 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1918 const creationResult = await this.helper.executeExtrinsic(1919 signer,1920 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1921 refungible: {1922 pieces: data.pieces,1923 properties: data.properties,1924 },1925 }],1926 true,1927 );1928 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1929 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1930 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1931 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1932 }19331934 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1935 throw Error('Not implemented');1936 const creationResult = await this.helper.executeExtrinsic(1937 signer,1938 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1939 true, // `Unable to mint RFT tokens for ${label}`,1940 );1941 const collection = this.getCollectionObject(collectionId);1942 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1943 }19441945 /**1946 * Mint multiple RFT tokens with one owner1947 * @param signer keyring of signer1948 * @param collectionId ID of collection1949 * @param owner tokens owner1950 * @param tokens array of tokens with properties and pieces1951 * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1952 * @returns array of newly created RFT tokens1953 */1954 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1955 const rawTokens = [];1956 for (const token of tokens) {1957 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1958 rawTokens.push(raw);1959 }1960 const creationResult = await this.helper.executeExtrinsic(1961 signer,1962 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1963 true,1964 );1965 const collection = this.getCollectionObject(collectionId);1966 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1967 }19681969 /**1970 * Destroys a concrete instance of RFT.1971 * @param signer keyring of signer1972 * @param collectionId ID of collection1973 * @param tokenId ID of token1974 * @param amount number of pieces to be burnt1975 * @example burnToken(aliceKeyring, 10, 5);1976 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1977 */1978 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1979 return await super.burnToken(signer, collectionId, tokenId, amount);1980 }19811982 /**1983 * Destroys a concrete instance of RFT on behalf of the owner.1984 * @param signer keyring of signer1985 * @param collectionId ID of collection1986 * @param tokenId ID of token1987 * @param fromAddressObj address on behalf of which the token will be burnt1988 * @param amount number of pieces to be burnt1989 * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1990 * @returns ```true``` if extrinsic success, otherwise ```false```1991 */1992 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1993 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1994 }19951996 /**1997 * Set, change, or remove approved address to transfer the ownership of the RFT.1998 *1999 * @param signer keyring of signer2000 * @param collectionId ID of collection2001 * @param tokenId ID of token2002 * @param toAddressObj address to approve2003 * @param amount number of pieces to be approved2004 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);2005 * @returns true if the token success, otherwise false2006 */2007 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {2008 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);2009 }20102011 /**2012 * Get total number of pieces2013 * @param collectionId ID of collection2014 * @param tokenId ID of token2015 * @example getTokenTotalPieces(10, 5);2016 * @returns number of pieces2017 */2018 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {2019 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();2020 }20212022 /**2023 * Change number of token pieces. Signer must be the owner of all token pieces.2024 * @param signer keyring of signer2025 * @param collectionId ID of collection2026 * @param tokenId ID of token2027 * @param amount new number of pieces2028 * @example repartitionToken(aliceKeyring, 10, 5, 12345n);2029 * @returns true if the repartion was success, otherwise false2030 */2031 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {2032 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);2033 const repartitionResult = await this.helper.executeExtrinsic(2034 signer,2035 'api.tx.unique.repartition', [collectionId, tokenId, amount],2036 true,2037 );2038 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');2039 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');2040 }2041}204220432044class FTGroup extends CollectionGroup {2045 /**2046 * Get collection object2047 * @param collectionId ID of collection2048 * @example getCollectionObject(2);2049 * @returns instance of UniqueFTCollection2050 */2051 getCollectionObject(collectionId: number): UniqueFTCollection {2052 return new UniqueFTCollection(collectionId, this.helper);2053 }20542055 /**2056 * Mint new fungible collection2057 * @param signer keyring of signer2058 * @param collectionOptions Collection options2059 * @param decimalPoints number of token decimals2060 * @example2061 * mintCollection(aliceKeyring, {2062 * name: 'New',2063 * description: 'New collection',2064 * tokenPrefix: 'NEW',2065 * }, 18)2066 * @returns newly created fungible collection2067 */2068 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {2069 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object2070 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');2071 collectionOptions.mode = {fungible: decimalPoints};2072 for (const key of ['name', 'description', 'tokenPrefix']) {2073 if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);2074 }2075 const creationResult = await this.helper.executeExtrinsic(2076 signer,2077 'api.tx.unique.createCollectionEx', [collectionOptions],2078 true,2079 );2080 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));2081 }20822083 /**2084 * Mint tokens2085 * @param signer keyring of signer2086 * @param collectionId ID of collection2087 * @param owner address owner of new tokens2088 * @param amount amount of tokens to be meanted2089 * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);2090 * @returns ```true``` if extrinsic success, otherwise ```false```2091 */2092 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {2093 const creationResult = await this.helper.executeExtrinsic(2094 signer,2095 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {2096 fungible: {2097 value: amount,2098 },2099 }],2100 true, // `Unable to mint fungible tokens for ${label}`,2101 );2102 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2103 }21042105 /**2106 * Mint multiple Fungible tokens with one owner2107 * @param signer keyring of signer2108 * @param collectionId ID of collection2109 * @param owner tokens owner2110 * @param tokens array of tokens with properties and pieces2111 * @returns ```true``` if extrinsic success, otherwise ```false```2112 */2113 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {2114 const rawTokens = [];2115 for (const token of tokens) {2116 const raw = {Fungible: {Value: token.value}};2117 rawTokens.push(raw);2118 }2119 const creationResult = await this.helper.executeExtrinsic(2120 signer,2121 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],2122 true,2123 );2124 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2125 }21262127 /**2128 * Get the top 10 owners with the largest balance for the Fungible collection2129 * @param collectionId ID of collection2130 * @example getTop10Owners(10);2131 * @returns array of ```ICrossAccountId```2132 */2133 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {2134 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);2135 }21362137 /**2138 * Get account balance2139 * @param collectionId ID of collection2140 * @param addressObj address of owner2141 * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})2142 * @returns amount of fungible tokens owned by address2143 */2144 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {2145 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();2146 }21472148 /**2149 * Transfer tokens to address2150 * @param signer keyring of signer2151 * @param collectionId ID of collection2152 * @param toAddressObj address recipient2153 * @param amount amount of tokens to be sent2154 * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2155 * @returns ```true``` if extrinsic success, otherwise ```false```2156 */2157 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2158 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);2159 }21602161 /**2162 * Transfer some tokens on behalf of the owner.2163 * @param signer keyring of signer2164 * @param collectionId ID of collection2165 * @param fromAddressObj address on behalf of which tokens will be sent2166 * @param toAddressObj address where token to be sent2167 * @param amount number of tokens to be sent2168 * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);2169 * @returns ```true``` if extrinsic success, otherwise ```false```2170 */2171 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2172 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2173 }21742175 /**2176 * Destroy some amount of tokens2177 * @param signer keyring of signer2178 * @param collectionId ID of collection2179 * @param amount amount of tokens to be destroyed2180 * @example burnTokens(aliceKeyring, 10, 1000n);2181 * @returns ```true``` if extrinsic success, otherwise ```false```2182 */2183 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {2184 return await super.burnToken(signer, collectionId, 0, amount);2185 }21862187 /**2188 * Burn some tokens on behalf of the owner.2189 * @param signer keyring of signer2190 * @param collectionId ID of collection2191 * @param fromAddressObj address on behalf of which tokens will be burnt2192 * @param amount amount of tokens to be burnt2193 * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2194 * @returns ```true``` if extrinsic success, otherwise ```false```2195 */2196 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {2197 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2198 }21992200 /**2201 * Get total collection supply2202 * @param collectionId2203 * @returns2204 */2205 async getTotalPieces(collectionId: number): Promise<bigint> {2206 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2207 }22082209 /**2210 * Set, change, or remove approved address to transfer tokens.2211 *2212 * @param signer keyring of signer2213 * @param collectionId ID of collection2214 * @param toAddressObj address to be approved2215 * @param amount amount of tokens to be approved2216 * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2217 * @returns ```true``` if extrinsic success, otherwise ```false```2218 */2219 approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2220 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2221 }22222223 /**2224 * Get amount of fungible tokens approved to transfer2225 * @param collectionId ID of collection2226 * @param fromAddressObj owner of tokens2227 * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2228 * @returns number of tokens approved for the transfer2229 */2230 getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2231 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2232 }2233}223422352236class ChainGroup extends HelperGroup<ChainHelperBase> {2237 /**2238 * Get system properties of a chain2239 * @example getChainProperties();2240 * @returns ss58Format, token decimals, and token symbol2241 */2242 getChainProperties(): IChainProperties {2243 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2244 return {2245 ss58Format: properties.ss58Format.toJSON(),2246 tokenDecimals: properties.tokenDecimals.toJSON(),2247 tokenSymbol: properties.tokenSymbol.toJSON(),2248 };2249 }22502251 /**2252 * Get chain header2253 * @example getLatestBlockNumber();2254 * @returns the number of the last block2255 */2256 async getLatestBlockNumber(): Promise<number> {2257 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2258 }22592260 /**2261 * Get block hash by block number2262 * @param blockNumber number of block2263 * @example getBlockHashByNumber(12345);2264 * @returns hash of a block2265 */2266 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2267 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2268 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2269 return blockHash;2270 }22712272 // TODO add docs2273 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2274 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2275 if (!blockHash) return null;2276 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2277 }22782279 /**2280 * Get latest relay block2281 * @returns {number} relay block2282 */2283 async getRelayBlockNumber(): Promise<bigint> {2284 const blockNumber = (await this.helper.callRpc('api.query.parachainSystem.validationData')).toJSON().relayParentNumber;2285 return BigInt(blockNumber);2286 }22872288 /**2289 * Get account nonce2290 * @param address substrate address2291 * @example getNonce("5GrwvaEF5zXb26Fz...");2292 * @returns number, account's nonce2293 */2294 async getNonce(address: TSubstrateAccount): Promise<number> {2295 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2296 }2297}22982299class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2300 /**2301 * Get substrate address balance2302 * @param address substrate address2303 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2304 * @returns amount of tokens on address2305 */2306 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2307 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2308 }23092310 /**2311 * Transfer tokens to substrate address2312 * @param signer keyring of signer2313 * @param address substrate address of a recipient2314 * @param amount amount of tokens to be transfered2315 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2316 * @returns ```true``` if extrinsic success, otherwise ```false```2317 */2318 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2319 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true/*, `Unable to transfer balance from ${this.helper.getSignerAddress(signer)} to ${address}`*/);23202321 let transfer = {from: null, to: null, amount: 0n} as any;2322 result.result.events.forEach(({event: {data, method, section}}) => {2323 if ((section === 'balances') && (method === 'Transfer')) {2324 transfer = {2325 from: this.helper.address.normalizeSubstrate(data[0]),2326 to: this.helper.address.normalizeSubstrate(data[1]),2327 amount: BigInt(data[2]),2328 };2329 }2330 });2331 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from2332 && this.helper.address.normalizeSubstrate(address) === transfer.to2333 && BigInt(amount) === transfer.amount;2334 return isSuccess;2335 }23362337 /**2338 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2339 * @param address substrate address2340 * @returns2341 */2342 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2343 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2344 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2345 }23462347 async getLocked(address: TSubstrateAccount): Promise<[{id: string, amount: bigint, reason: string}]> {2348 const locks = (await this.helper.callRpc('api.query.balances.locks', [address])).toHuman();2349 return locks.map((lock: any) => {return {id: lock.id, amount: BigInt(lock.amount.replace(/,/g, '')), reasons: lock.reasons};});2350 }2351}23522353class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2354 /**2355 * Get ethereum address balance2356 * @param address ethereum address2357 * @example getEthereum("0x9F0583DbB855d...")2358 * @returns amount of tokens on address2359 */2360 async getEthereum(address: TEthereumAccount): Promise<bigint> {2361 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2362 }23632364 /**2365 * Transfer tokens to address2366 * @param signer keyring of signer2367 * @param address Ethereum address of a recipient2368 * @param amount amount of tokens to be transfered2369 * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2370 * @returns ```true``` if extrinsic success, otherwise ```false```2371 */2372 async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2373 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);23742375 let transfer = {from: null, to: null, amount: 0n} as any;2376 result.result.events.forEach(({event: {data, method, section}}) => {2377 if ((section === 'balances') && (method === 'Transfer')) {2378 transfer = {2379 from: data[0].toString(),2380 to: data[1].toString(),2381 amount: BigInt(data[2]),2382 };2383 }2384 });2385 const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from2386 && address === transfer.to2387 && BigInt(amount) === transfer.amount;2388 return isSuccess;2389 }2390}23912392class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2393 subBalanceGroup: SubstrateBalanceGroup<T>;2394 ethBalanceGroup: EthereumBalanceGroup<T>;23952396 constructor(helper: T) {2397 super(helper);2398 this.subBalanceGroup = new SubstrateBalanceGroup(helper);2399 this.ethBalanceGroup = new EthereumBalanceGroup(helper);2400 }24012402 getCollectionCreationPrice(): bigint {2403 return 2n * this.getOneTokenNominal();2404 }2405 /**2406 * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2407 * @example getOneTokenNominal()2408 * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2409 */2410 getOneTokenNominal(): bigint {2411 const chainProperties = this.helper.chain.getChainProperties();2412 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2413 }24142415 /**2416 * Get substrate address balance2417 * @param address substrate address2418 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2419 * @returns amount of tokens on address2420 */2421 getSubstrate(address: TSubstrateAccount): Promise<bigint> {2422 return this.subBalanceGroup.getSubstrate(address);2423 }24242425 /**2426 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2427 * @param address substrate address2428 * @returns2429 */2430 getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2431 return this.subBalanceGroup.getSubstrateFull(address);2432 }24332434 /**2435 * Get locked balances2436 * @param address substrate address2437 * @returns locked balances with reason via api.query.balances.locks2438 */2439 getLocked(address: TSubstrateAccount) {2440 return this.subBalanceGroup.getLocked(address);2441 }24422443 /**2444 * Get ethereum address balance2445 * @param address ethereum address2446 * @example getEthereum("0x9F0583DbB855d...")2447 * @returns amount of tokens on address2448 */2449 getEthereum(address: TEthereumAccount): Promise<bigint> {2450 return this.ethBalanceGroup.getEthereum(address);2451 }24522453 async setBalanceSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint, reservedAmount = 0n) {2454 await this.helper.executeExtrinsic(signer, 'api.tx.balances.setBalance', [address, amount, reservedAmount], true);2455 }24562457 /**2458 * Transfer tokens to substrate address2459 * @param signer keyring of signer2460 * @param address substrate address of a recipient2461 * @param amount amount of tokens to be transfered2462 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2463 * @returns ```true``` if extrinsic success, otherwise ```false```2464 */2465 transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2466 return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2467 }24682469 async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2470 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);24712472 let transfer = {from: null, to: null, amount: 0n} as any;2473 result.result.events.forEach(({event: {data, method, section}}) => {2474 if ((section === 'balances') && (method === 'Transfer')) {2475 transfer = {2476 from: this.helper.address.normalizeSubstrate(data[0]),2477 to: this.helper.address.normalizeSubstrate(data[1]),2478 amount: BigInt(data[2]),2479 };2480 }2481 });2482 let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2483 isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2484 isSuccess = isSuccess && BigInt(amount) === transfer.amount;2485 return isSuccess;2486 }24872488 /**2489 * Transfer tokens with the unlock period2490 * @param signer signers Keyring2491 * @param address Substrate address of recipient2492 * @param schedule Schedule params2493 * @example vestedTransfer(signer, recepient.address, 20000, 100, 10, 50 * nominal); // total amount of vested tokens will be 100 * 50 = 50002494 */2495 async vestedTransfer(signer: TSigner, address: TSubstrateAccount, schedule: {start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}): Promise<void> {2496 const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.vestedTransfer', [address, schedule]);2497 const event = result.result.events2498 .find(e => e.event.section === 'vesting' &&2499 e.event.method === 'VestingScheduleAdded' &&2500 e.event.data[0].toHuman() === signer.address);2501 if (!event) throw Error('Cannot find transfer in events');2502 }25032504 /**2505 * Get schedule for recepient of vested transfer2506 * @param address Substrate address of recipient2507 * @returns2508 */2509 async getVestingSchedules(address: TSubstrateAccount): Promise<{start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}[]> {2510 const schedule = (await this.helper.callRpc('api.query.vesting.vestingSchedules', [address])).toJSON();2511 return schedule.map((schedule: any) => {2512 return {2513 start: BigInt(schedule.start),2514 period: BigInt(schedule.period),2515 periodCount: BigInt(schedule.periodCount),2516 perPeriod: BigInt(schedule.perPeriod),2517 };2518 });2519 }25202521 /**2522 * Claim vested tokens2523 * @param signer signers Keyring2524 */2525 async claim(signer: TSigner) {2526 const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.claim', []);2527 const event = result.result.events2528 .find(e => e.event.section === 'vesting' &&2529 e.event.method === 'Claimed' &&2530 e.event.data[0].toHuman() === signer.address);2531 if (!event) throw Error('Cannot find claim in events');2532 }2533}25342535class AddressGroup extends HelperGroup<ChainHelperBase> {2536 /**2537 * Normalizes the address to the specified ss58 format, by default ```42```.2538 * @param address substrate address2539 * @param ss58Format format for address conversion, by default ```42```2540 * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2541 * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2542 */2543 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2544 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2545 }25462547 /**2548 * Get address in the connected chain format2549 * @param address substrate address2550 * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2551 * @returns address in chain format2552 */2553 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2554 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2555 }25562557 /**2558 * Get substrate mirror of an ethereum address2559 * @param ethAddress ethereum address2560 * @param toChainFormat false for normalized account2561 * @example ethToSubstrate('0x9F0583DbB855d...')2562 * @returns substrate mirror of a provided ethereum address2563 */2564 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2565 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2566 }25672568 /**2569 * Get ethereum mirror of a substrate address2570 * @param subAddress substrate account2571 * @example substrateToEth("5DnSF6RRjwteE3BrC...")2572 * @returns ethereum mirror of a provided substrate address2573 */2574 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2575 return CrossAccountId.translateSubToEth(subAddress);2576 }25772578 /**2579 * Encode key to substrate address2580 * @param key key for encoding address2581 * @param ss58Format prefix for encoding to the address of the corresponding network2582 * @returns encoded substrate address2583 */2584 encodeSubstrateAddress (key: Uint8Array | string | bigint, ss58Format = 42): string {2585 const u8a :Uint8Array = typeof key === 'string'2586 ? hexToU8a(key)2587 : typeof key === 'bigint'2588 ? hexToU8a(key.toString(16))2589 : key;25902591 if (ss58Format < 0 || ss58Format > 16383 || [46, 47].includes(ss58Format)) {2592 throw new Error(`ss58Format is not valid, received ${typeofss58Format} "${ss58Format}"`);2593 }25942595 const allowedDecodedLengths = [1, 2, 4, 8, 32, 33];2596 if (!allowedDecodedLengths.includes(u8a.length)) {2597 throw new Error(`key length is not valid, received ${u8a.length}, valid values are ${allowedDecodedLengths.join(', ')}`);2598 }25992600 const u8aPrefix = ss58Format < 642601 ? new Uint8Array([ss58Format])2602 : new Uint8Array([2603 ((ss58Format & 0xfc) >> 2) | 0x40,2604 (ss58Format >> 8) | ((ss58Format & 0x03) << 6),2605 ]);26062607 const input = u8aConcat(u8aPrefix, u8a);26082609 return base58Encode(u8aConcat(2610 input,2611 blake2AsU8a(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1),2612 ));2613 }26142615 /**2616 * Restore substrate address from bigint representation2617 * @param number decimal representation of substrate address2618 * @returns substrate address2619 */2620 restoreCrossAccountFromBigInt(number: bigint): TSubstrateAccount {2621 if (this.helper.api === null) {2622 throw 'Not connected';2623 }2624 const res = this.helper.api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();2625 if (res === undefined || res === null) {2626 throw 'Restore address error';2627 }2628 return res.toString();2629 }26302631 /**2632 * Convert etherium cross account id to substrate cross account id2633 * @param ethCrossAccount etherium cross account2634 * @returns substrate cross account id2635 */2636 convertCrossAccountFromEthCrossAccount(ethCrossAccount: IEthCrossAccountId): ICrossAccountId {2637 if (ethCrossAccount.sub === '0') {2638 return {Ethereum: ethCrossAccount.eth.toLocaleLowerCase()};2639 }26402641 const ss58 = this.restoreCrossAccountFromBigInt(BigInt(ethCrossAccount.sub));2642 return {Substrate: ss58};2643 }26442645 paraSiblingSovereignAccount(paraid: number) {2646 // We are getting a *sibling* parachain sovereign account,2647 // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c2648 const siblingPrefix = '0x7369626c';26492650 const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2651 const suffix = '000000000000000000000000000000000000000000000000';26522653 return siblingPrefix + encodedParaId + suffix;2654 }2655}26562657class StakingGroup extends HelperGroup<UniqueHelper> {2658 /**2659 * Stake tokens for App Promotion2660 * @param signer keyring of signer2661 * @param amountToStake amount of tokens to stake2662 * @param label extra label for log2663 * @returns2664 */2665 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2666 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2667 const _stakeResult = await this.helper.executeExtrinsic(2668 signer, 'api.tx.appPromotion.stake',2669 [amountToStake], true,2670 );2671 // TODO extract info from stakeResult2672 return true;2673 }26742675 /**2676 * Unstake all staked tokens2677 * @param signer keyring of signer2678 * @param amountToUnstake amount of tokens to unstake2679 * @param label extra label for log2680 * @returns block hash where unstake happened2681 */2682 async unstakeAll(signer: TSigner, label?: string): Promise<string> {2683 if(typeof label === 'undefined') label = `${signer.address}`;2684 const unstakeResult = await this.helper.executeExtrinsic(2685 signer, 'api.tx.appPromotion.unstakeAll',2686 [], true,2687 );2688 return unstakeResult.blockHash;2689 }26902691 /**2692 * Unstake the part of a staked tokens2693 * @param signer keyring of signer2694 * @param amount amount of tokens to unstake2695 * @param label extra label for log2696 * @returns block hash where unstake happened2697 */2698 async unstakePartial(signer: TSigner, amount: bigint, label?: string): Promise<string> {2699 if(typeof label === 'undefined') label = `${signer.address}`;2700 const unstakeResult = await this.helper.executeExtrinsic(2701 signer, 'api.tx.appPromotion.unstakePartial',2702 [amount], true,2703 );2704 return unstakeResult.blockHash;2705 }27062707 /**2708 * Get total number of active stakes2709 * @param address substrate address2710 * @returns {number}2711 */2712 async getStakesNumber(address: ICrossAccountId): Promise<number> {2713 if (address.Ethereum) throw Error('only substrate address');2714 return (await this.helper.callRpc('api.query.appPromotion.stakesPerAccount', [address.Substrate])).toNumber();2715 }27162717 /**2718 * Get total staked amount for address2719 * @param address substrate or ethereum address2720 * @returns total staked amount2721 */2722 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2723 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2724 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2725 }27262727 /**2728 * Get total staked per block2729 * @param address substrate or ethereum address2730 * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2731 */2732 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2733 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2734 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2735 return {2736 block: block.toBigInt(),2737 amount: amount.toBigInt(),2738 };2739 });2740 }27412742 /**2743 * Get total pending unstake amount for address2744 * @param address substrate or ethereum address2745 * @returns total pending unstake amount2746 */2747 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2748 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2749 }27502751 /**2752 * Get pending unstake amount per block for address2753 * @param address substrate or ethereum address2754 * @returns array of pending stakes. `block` – the number of the block in which the unstake was made. `amount` - the number of tokens unstaked in the block2755 */2756 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2757 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2758 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2759 return {2760 block: block.toBigInt(),2761 amount: amount.toBigInt(),2762 };2763 });2764 return result;2765 }2766}27672768class SchedulerGroup extends HelperGroup<UniqueHelper> {2769 constructor(helper: UniqueHelper) {2770 super(helper);2771 }27722773 cancelScheduled(signer: TSigner, scheduledId: string) {2774 return this.helper.executeExtrinsic(2775 signer,2776 'api.tx.scheduler.cancelNamed',2777 [scheduledId],2778 true,2779 );2780 }27812782 changePriority(signer: TSigner, scheduledId: string, priority: number) {2783 return this.helper.executeExtrinsic(2784 signer,2785 'api.tx.scheduler.changeNamedPriority',2786 [scheduledId, priority],2787 true,2788 );2789 }27902791 scheduleAt<T extends UniqueHelper>(2792 executionBlockNumber: number,2793 options: ISchedulerOptions = {},2794 ) {2795 return this.schedule<T>('schedule', executionBlockNumber, options);2796 }27972798 scheduleAfter<T extends UniqueHelper>(2799 blocksBeforeExecution: number,2800 options: ISchedulerOptions = {},2801 ) {2802 return this.schedule<T>('scheduleAfter', blocksBeforeExecution, options);2803 }28042805 schedule<T extends UniqueHelper>(2806 scheduleFn: 'schedule' | 'scheduleAfter',2807 blocksNum: number,2808 options: ISchedulerOptions = {},2809 ) {2810 // eslint-disable-next-line @typescript-eslint/naming-convention2811 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2812 return this.helper.clone(ScheduledHelperType, {2813 scheduleFn,2814 blocksNum,2815 options,2816 }) as T;2817 }2818}28192820class CollatorSelectionGroup extends HelperGroup<UniqueHelper> {2821 //todo:collator documentation2822 addInvulnerable(signer: TSigner, address: string) {2823 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.addInvulnerable', [address]);2824 }28252826 removeInvulnerable(signer: TSigner, address: string) {2827 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.removeInvulnerable', [address]);2828 }28292830 async getInvulnerables(): Promise<string[]> {2831 return (await this.helper.callRpc('api.query.collatorSelection.invulnerables')).map((x: any) => x.toHuman());2832 }28332834 /** and also total max invulnerables */2835 maxCollators(): number {2836 return (this.helper.getApi().consts.configuration.defaultCollatorSelectionMaxCollators.toJSON() as number);2837 }28382839 async getDesiredCollators(): Promise<number> {2840 return (await this.helper.callRpc('api.query.configuration.collatorSelectionDesiredCollatorsOverride')).toNumber();2841 }28422843 setLicenseBond(signer: TSigner, amount: bigint) {2844 return this.helper.executeExtrinsic(signer, 'api.tx.configuration.setCollatorSelectionLicenseBond', [amount]);2845 }28462847 async getLicenseBond(): Promise<bigint> {2848 return (await this.helper.callRpc('api.query.configuration.collatorSelectionLicenseBondOverride')).toBigInt();2849 }28502851 obtainLicense(signer: TSigner) {2852 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.getLicense', []);2853 }28542855 releaseLicense(signer: TSigner) {2856 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.releaseLicense', []);2857 }28582859 forceReleaseLicense(signer: TSigner, released: string) {2860 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.forceReleaseLicense', [released]);2861 }28622863 async hasLicense(address: string): Promise<bigint> {2864 return (await this.helper.callRpc('api.query.collatorSelection.licenseDepositOf', [address])).toBigInt();2865 }28662867 onboard(signer: TSigner) {2868 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.onboard', []);2869 }28702871 offboard(signer: TSigner) {2872 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.offboard', []);2873 }28742875 async getCandidates(): Promise<string[]> {2876 return (await this.helper.callRpc('api.query.collatorSelection.candidates')).map((x: any) => x.toHuman());2877 }2878}28792880class PreimageGroup extends HelperGroup<UniqueHelper> {2881 async getPreimageInfo(h256: string) {2882 return (await this.helper.callRpc('api.query.preimage.statusFor', [h256])).toJSON();2883 }28842885 /**2886 * Create a preimage with a hex or a byte array.2887 * @param signer keyring of the signer.2888 * @param bytes preimage encoded in hex or a byte array, e.g. an extrinsic call.2889 * @example await notePreimage(preimageMaker,2890 * helper.constructApiCall('api.tx.identity.forceInsertIdentities', [identitiesToAdd]).method.toHex()2891 * );2892 * @returns promise of extrinsic execution.2893 */2894 notePreimage(signer: TSigner, bytes: string | Uint8Array) {2895 return this.helper.executeExtrinsic(signer, 'api.tx.preimage.notePreimage', [bytes]);2896 }28972898 /**2899 * Delete an existing preimage and return the deposit.2900 * @param signer keyring of the signer - either the owner or the preimage manager (sudo).2901 * @param h256 hash of the preimage.2902 * @returns promise of extrinsic execution.2903 */2904 unnotePreimage(signer: TSigner, h256: string) {2905 return this.helper.executeExtrinsic(signer, 'api.tx.preimage.unnotePreimage', [h256]);2906 }29072908 /**2909 * Request a preimage be uploaded to the chain without paying any fees or deposits.2910 * @param signer keyring of the signer - either the owner or the preimage manager (sudo).2911 * @param h256 hash of the preimage.2912 * @returns promise of extrinsic execution.2913 */2914 requestPreimage(signer: TSigner, h256: string) {2915 return this.helper.executeExtrinsic(signer, 'api.tx.preimage.requestPreimage', [h256]);2916 }29172918 /**2919 * Clear a previously made request for a preimage.2920 * @param signer keyring of the signer - either the owner or the preimage manager (sudo).2921 * @param h256 hash of the preimage.2922 * @returns promise of extrinsic execution.2923 */2924 unrequestPreimage(signer: TSigner, h256: string) {2925 return this.helper.executeExtrinsic(signer, 'api.tx.preimage.unrequestPreimage', [h256]);2926 }2927}29282929class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2930 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2931 await this.helper.executeExtrinsic(2932 signer,2933 'api.tx.foreignAssets.registerForeignAsset',2934 [ownerAddress, location, metadata],2935 true,2936 );2937 }29382939 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2940 await this.helper.executeExtrinsic(2941 signer,2942 'api.tx.foreignAssets.updateForeignAsset',2943 [foreignAssetId, location, metadata],2944 true,2945 );2946 }2947}29482949class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2950 palletName: string;29512952 constructor(helper: T, palletName: string) {2953 super(helper);29542955 this.palletName = palletName;2956 }29572958 async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: any) {2959 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, weightLimit], true);2960 }29612962 async setSafeXcmVersion(signer: TSigner, version: number) {2963 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.forceDefaultXcmVersion`, [version], true);2964 }29652966 async teleportAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number) {2967 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.teleportAssets`, [destination, beneficiary, assets, feeAssetItem], true);2968 }29692970 async teleportNativeAsset(signer: TSigner, destinationParaId: number, targetAccount: Uint8Array, amount: bigint, xcmVersion = 3) {2971 const destinationContent = {2972 parents: 0,2973 interior: {2974 X1: {2975 Parachain: destinationParaId,2976 },2977 },2978 };29792980 const beneficiaryContent = {2981 parents: 0,2982 interior: {2983 X1: {2984 AccountId32: {2985 network: 'Any',2986 id: targetAccount,2987 },2988 },2989 },2990 };29912992 const assetsContent = [2993 {2994 id: {2995 Concrete: {2996 parents: 0,2997 interior: 'Here',2998 },2999 },3000 fun: {3001 Fungible: amount,3002 },3003 },3004 ];30053006 let destination;3007 let beneficiary;3008 let assets;30093010 if (xcmVersion == 2) {3011 destination = {V1: destinationContent};3012 beneficiary = {V1: beneficiaryContent};3013 assets = {V1: assetsContent};30143015 } else if (xcmVersion == 3) {3016 destination = {V2: destinationContent};3017 beneficiary = {V2: beneficiaryContent};3018 assets = {V2: assetsContent};30193020 } else {3021 throw Error('Unknown XCM version: ' + xcmVersion);3022 }30233024 const feeAssetItem = 0;30253026 await this.teleportAssets(signer, destination, beneficiary, assets, feeAssetItem);3027 }30283029 async send(signer: IKeyringPair, destination: any, message: any) {3030 await this.helper.executeExtrinsic(3031 signer,3032 `api.tx.${this.palletName}.send`,3033 [3034 destination,3035 message,3036 ],3037 true,3038 );3039 }3040}30413042class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {3043 async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: any) {3044 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);3045 }30463047 async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: any) {3048 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);3049 }30503051 async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: any) {3052 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);3053 }3054}30553056class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {3057 async accounts(address: string, currencyId: any) {3058 const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;3059 return BigInt(free);3060 }3061}30623063class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {3064 async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {3065 await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);3066 }30673068 async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {3069 await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);3070 }30713072 async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {3073 await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);3074 }30753076 async account(assetId: string | number, address: string) {3077 const accountAsset = (3078 await this.helper.callRpc('api.query.assets.account', [assetId, address])3079 ).toJSON()! as any;30803081 if (accountAsset !== null) {3082 return BigInt(accountAsset['balance']);3083 } else {3084 return null;3085 }3086 }3087}30883089class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {3090 async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {3091 await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);3092 }3093}30943095class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {3096 makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {3097 const apiPrefix = 'api.tx.assetManager.';30983099 const registerTx = this.helper.constructApiCall(3100 apiPrefix + 'registerForeignAsset',3101 [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],3102 );31033104 const setUnitsTx = this.helper.constructApiCall(3105 apiPrefix + 'setAssetUnitsPerSecond',3106 [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],3107 );31083109 const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);3110 const encodedProposal = batchCall?.method.toHex() || '';3111 return encodedProposal;3112 }31133114 async assetTypeId(location: any) {3115 return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);3116 }3117}31183119class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {3120 notePreimagePallet: string;31213122 constructor(helper: MoonbeamHelper, options: {[key: string]: any} = {}) {3123 super(helper);3124 this.notePreimagePallet = options.notePreimagePallet;3125 }31263127 async notePreimage(signer: TSigner, encodedProposal: string) {3128 await this.helper.executeExtrinsic(signer, `api.tx.${this.notePreimagePallet}.notePreimage`, [encodedProposal], true);3129 }31303131 externalProposeMajority(proposal: any) {3132 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposal]);3133 }31343135 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {3136 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);3137 }31383139 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {3140 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);3141 }3142}31433144class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {3145 collective: string;31463147 constructor(helper: MoonbeamHelper, collective: string) {3148 super(helper);31493150 this.collective = collective;3151 }31523153 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {3154 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);3155 }31563157 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {3158 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);3159 }31603161 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: any, lengthBound: number) {3162 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);3163 }31643165 async proposalCount() {3166 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));3167 }3168}31693170export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;3171export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;31723173export class UniqueHelper extends ChainHelperBase {3174 balance: BalanceGroup<UniqueHelper>;3175 collection: CollectionGroup;3176 nft: NFTGroup;3177 rft: RFTGroup;3178 ft: FTGroup;3179 staking: StakingGroup;3180 scheduler: SchedulerGroup;3181 collatorSelection: CollatorSelectionGroup;3182 preimage: PreimageGroup;3183 foreignAssets: ForeignAssetsGroup;3184 xcm: XcmGroup<UniqueHelper>;3185 xTokens: XTokensGroup<UniqueHelper>;3186 tokens: TokensGroup<UniqueHelper>;31873188 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3189 super(logger, options.helperBase ?? UniqueHelper);31903191 this.balance = new BalanceGroup(this);3192 this.collection = new CollectionGroup(this);3193 this.nft = new NFTGroup(this);3194 this.rft = new RFTGroup(this);3195 this.ft = new FTGroup(this);3196 this.staking = new StakingGroup(this);3197 this.scheduler = new SchedulerGroup(this);3198 this.collatorSelection = new CollatorSelectionGroup(this);3199 this.preimage = new PreimageGroup(this);3200 this.foreignAssets = new ForeignAssetsGroup(this);3201 this.xcm = new XcmGroup(this, 'polkadotXcm');3202 this.xTokens = new XTokensGroup(this);3203 this.tokens = new TokensGroup(this);3204 }32053206 getSudo<T extends UniqueHelper>() {3207 // eslint-disable-next-line @typescript-eslint/naming-convention3208 const SudoHelperType = SudoHelper(this.helperBase);3209 return this.clone(SudoHelperType) as T;3210 }3211}32123213export class XcmChainHelper extends ChainHelperBase {3214 async connect(wsEndpoint: string, _listeners?: any): Promise<void> {3215 const wsProvider = new WsProvider(wsEndpoint);3216 this.api = new ApiPromise({3217 provider: wsProvider,3218 });3219 await this.api.isReadyOrError;3220 this.network = await UniqueHelper.detectNetwork(this.api);3221 }3222}32233224export class RelayHelper extends XcmChainHelper {3225 balance: SubstrateBalanceGroup<RelayHelper>;3226 xcm: XcmGroup<RelayHelper>;32273228 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3229 super(logger, options.helperBase ?? RelayHelper);32303231 this.balance = new SubstrateBalanceGroup(this);3232 this.xcm = new XcmGroup(this, 'xcmPallet');3233 }3234}32353236export class WestmintHelper extends XcmChainHelper {3237 balance: SubstrateBalanceGroup<WestmintHelper>;3238 xcm: XcmGroup<WestmintHelper>;3239 assets: AssetsGroup<WestmintHelper>;3240 xTokens: XTokensGroup<WestmintHelper>;32413242 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3243 super(logger, options.helperBase ?? WestmintHelper);32443245 this.balance = new SubstrateBalanceGroup(this);3246 this.xcm = new XcmGroup(this, 'polkadotXcm');3247 this.assets = new AssetsGroup(this);3248 this.xTokens = new XTokensGroup(this);3249 }3250}32513252export class MoonbeamHelper extends XcmChainHelper {3253 balance: EthereumBalanceGroup<MoonbeamHelper>;3254 assetManager: MoonbeamAssetManagerGroup;3255 assets: AssetsGroup<MoonbeamHelper>;3256 xTokens: XTokensGroup<MoonbeamHelper>;3257 democracy: MoonbeamDemocracyGroup;3258 collective: {3259 council: MoonbeamCollectiveGroup,3260 techCommittee: MoonbeamCollectiveGroup,3261 };32623263 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3264 super(logger, options.helperBase ?? MoonbeamHelper);32653266 this.balance = new EthereumBalanceGroup(this);3267 this.assetManager = new MoonbeamAssetManagerGroup(this);3268 this.assets = new AssetsGroup(this);3269 this.xTokens = new XTokensGroup(this);3270 this.democracy = new MoonbeamDemocracyGroup(this, options);3271 this.collective = {3272 council: new MoonbeamCollectiveGroup(this, 'councilCollective'),3273 techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),3274 };3275 }3276}32773278export class AstarHelper extends XcmChainHelper {3279 balance: SubstrateBalanceGroup<AstarHelper>;3280 assets: AssetsGroup<AstarHelper>;3281 xcm: XcmGroup<AstarHelper>;32823283 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3284 super(logger, options.helperBase ?? AstarHelper);32853286 this.balance = new SubstrateBalanceGroup(this);3287 this.assets = new AssetsGroup(this);3288 this.xcm = new XcmGroup(this, 'polkadotXcm');3289 }32903291 getSudo<T extends UniqueHelper>() {3292 // eslint-disable-next-line @typescript-eslint/naming-convention3293 const SudoHelperType = SudoHelper(this.helperBase);3294 return this.clone(SudoHelperType) as T;3295 }3296}32973298export class AcalaHelper extends XcmChainHelper {3299 balance: SubstrateBalanceGroup<AcalaHelper>;3300 assetRegistry: AcalaAssetRegistryGroup;3301 xTokens: XTokensGroup<AcalaHelper>;3302 tokens: TokensGroup<AcalaHelper>;3303 xcm: XcmGroup<AcalaHelper>;33043305 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3306 super(logger, options.helperBase ?? AcalaHelper);33073308 this.balance = new SubstrateBalanceGroup(this);3309 this.assetRegistry = new AcalaAssetRegistryGroup(this);3310 this.xTokens = new XTokensGroup(this);3311 this.tokens = new TokensGroup(this);3312 this.xcm = new XcmGroup(this, 'polkadotXcm');3313 }33143315 getSudo<T extends AcalaHelper>() {3316 // eslint-disable-next-line @typescript-eslint/naming-convention3317 const SudoHelperType = SudoHelper(this.helperBase);3318 return this.clone(SudoHelperType) as T;3319 }3320}33213322// eslint-disable-next-line @typescript-eslint/naming-convention3323function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {3324 return class extends Base {3325 scheduleFn: 'schedule' | 'scheduleAfter';3326 blocksNum: number;3327 options: ISchedulerOptions;33283329 constructor(...args: any[]) {3330 const logger = args[0] as ILogger;3331 const options = args[1] as {3332 scheduleFn: 'schedule' | 'scheduleAfter',3333 blocksNum: number,3334 options: ISchedulerOptions3335 };33363337 super(logger);33383339 this.scheduleFn = options.scheduleFn;3340 this.blocksNum = options.blocksNum;3341 this.options = options.options;3342 }33433344 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {3345 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);33463347 const mandatorySchedArgs = [3348 this.blocksNum,3349 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,3350 this.options.priority ?? null,3351 scheduledTx,3352 ];33533354 let schedArgs;3355 let scheduleFn;33563357 if (this.options.scheduledId) {3358 schedArgs = [this.options.scheduledId!, ...mandatorySchedArgs];33593360 if (this.scheduleFn == 'schedule') {3361 scheduleFn = 'scheduleNamed';3362 } else if (this.scheduleFn == 'scheduleAfter') {3363 scheduleFn = 'scheduleNamedAfter';3364 }3365 } else {3366 schedArgs = mandatorySchedArgs;3367 scheduleFn = this.scheduleFn;3368 }33693370 const extrinsic = 'api.tx.scheduler.' + scheduleFn;33713372 return super.executeExtrinsic(3373 sender,3374 extrinsic,3375 schedArgs,3376 expectSuccess,3377 );3378 }3379 };3380}33813382// eslint-disable-next-line @typescript-eslint/naming-convention3383function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {3384 return class extends Base {3385 constructor(...args: any[]) {3386 super(...args);3387 }33883389 async executeExtrinsic(3390 sender: IKeyringPair,3391 extrinsic: string,3392 params: any[],3393 expectSuccess?: boolean,3394 options: Partial<SignerOptions>|null = null,3395 ): Promise<ITransactionResult> {3396 const call = this.constructApiCall(extrinsic, params);3397 const result = await super.executeExtrinsic(3398 sender,3399 'api.tx.sudo.sudo',3400 [call],3401 expectSuccess,3402 options,3403 );34043405 if (result.status === 'Fail') return result;34063407 const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;3408 if (data.isErr) {3409 if (data.asErr.isModule) {3410 const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;3411 const metaError = super.getApi()?.registry.findMetaError(error);3412 throw new Error(`${metaError.section}.${metaError.name}`);3413 } else {3414 throw new Error(data.asErr.toHuman());3415 }3416 }3417 return result;3418 }3419 };3420}34213422export class UniqueBaseCollection {3423 helper: UniqueHelper;3424 collectionId: number;34253426 constructor(collectionId: number, uniqueHelper: UniqueHelper) {3427 this.collectionId = collectionId;3428 this.helper = uniqueHelper;3429 }34303431 async getData() {3432 return await this.helper.collection.getData(this.collectionId);3433 }34343435 async getLastTokenId() {3436 return await this.helper.collection.getLastTokenId(this.collectionId);3437 }34383439 async doesTokenExist(tokenId: number) {3440 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);3441 }34423443 async getAdmins() {3444 return await this.helper.collection.getAdmins(this.collectionId);3445 }34463447 async getAllowList() {3448 return await this.helper.collection.getAllowList(this.collectionId);3449 }34503451 async getEffectiveLimits() {3452 return await this.helper.collection.getEffectiveLimits(this.collectionId);3453 }34543455 async getProperties(propertyKeys?: string[] | null) {3456 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);3457 }34583459 async getPropertiesConsumedSpace() {3460 return await this.helper.collection.getPropertiesConsumedSpace(this.collectionId);3461 }34623463 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {3464 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);3465 }34663467 async getOptions() {3468 return await this.helper.collection.getCollectionOptions(this.collectionId);3469 }34703471 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {3472 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);3473 }34743475 async confirmSponsorship(signer: TSigner) {3476 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);3477 }34783479 async removeSponsor(signer: TSigner) {3480 return await this.helper.collection.removeSponsor(signer, this.collectionId);3481 }34823483 async setLimits(signer: TSigner, limits: ICollectionLimits) {3484 return await this.helper.collection.setLimits(signer, this.collectionId, limits);3485 }34863487 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {3488 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);3489 }34903491 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3492 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);3493 }34943495 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {3496 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);3497 }34983499 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {3500 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);3501 }35023503 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3504 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);3505 }35063507 async setProperties(signer: TSigner, properties: IProperty[]) {3508 return await this.helper.collection.setProperties(signer, this.collectionId, properties);3509 }35103511 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3512 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);3513 }35143515 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {3516 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);3517 }35183519 async enableNesting(signer: TSigner, permissions: INestingPermissions) {3520 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);3521 }35223523 async disableNesting(signer: TSigner) {3524 return await this.helper.collection.disableNesting(signer, this.collectionId);3525 }35263527 async burn(signer: TSigner) {3528 return await this.helper.collection.burn(signer, this.collectionId);3529 }35303531 scheduleAt<T extends UniqueHelper>(3532 executionBlockNumber: number,3533 options: ISchedulerOptions = {},3534 ) {3535 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3536 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3537 }35383539 scheduleAfter<T extends UniqueHelper>(3540 blocksBeforeExecution: number,3541 options: ISchedulerOptions = {},3542 ) {3543 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3544 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3545 }35463547 getSudo<T extends UniqueHelper>() {3548 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());3549 }3550}355135523553export class UniqueNFTCollection extends UniqueBaseCollection {3554 getTokenObject(tokenId: number) {3555 return new UniqueNFToken(tokenId, this);3556 }35573558 async getTokensByAddress(addressObj: ICrossAccountId) {3559 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);3560 }35613562 async getToken(tokenId: number, blockHashAt?: string) {3563 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);3564 }35653566 async getTokenOwner(tokenId: number, blockHashAt?: string) {3567 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3568 }35693570 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3571 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3572 }35733574 async getTokenChildren(tokenId: number, blockHashAt?: string) {3575 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);3576 }35773578 async getPropertyPermissions(propertyKeys: string[] | null = null) {3579 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);3580 }35813582 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3583 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3584 }35853586 async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3587 const api = this.helper.getApi();3588 const props = (await api.query.nonfungible.tokenProperties(this.collectionId, tokenId)).toJSON();35893590 return (props! as any).consumedSpace;3591 }35923593 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {3594 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);3595 }35963597 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3598 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);3599 }36003601 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {3602 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);3603 }36043605 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {3606 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);3607 }36083609 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3610 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});3611 }36123613 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {3614 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);3615 }36163617 async burnToken(signer: TSigner, tokenId: number) {3618 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);3619 }36203621 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {3622 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);3623 }36243625 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3626 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);3627 }36283629 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3630 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3631 }36323633 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3634 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3635 }36363637 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3638 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3639 }36403641 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3642 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3643 }36443645 scheduleAt<T extends UniqueHelper>(3646 executionBlockNumber: number,3647 options: ISchedulerOptions = {},3648 ) {3649 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3650 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3651 }36523653 scheduleAfter<T extends UniqueHelper>(3654 blocksBeforeExecution: number,3655 options: ISchedulerOptions = {},3656 ) {3657 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3658 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3659 }36603661 getSudo<T extends UniqueHelper>() {3662 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());3663 }3664}366536663667export class UniqueRFTCollection extends UniqueBaseCollection {3668 getTokenObject(tokenId: number) {3669 return new UniqueRFToken(tokenId, this);3670 }36713672 async getToken(tokenId: number, blockHashAt?: string) {3673 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);3674 }36753676 async getTokenOwner(tokenId: number, blockHashAt?: string) {3677 return await this.helper.rft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3678 }36793680 async getTokensByAddress(addressObj: ICrossAccountId) {3681 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);3682 }36833684 async getTop10TokenOwners(tokenId: number) {3685 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);3686 }36873688 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3689 return await this.helper.rft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3690 }36913692 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {3693 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3694 }36953696 async getTokenTotalPieces(tokenId: number) {3697 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3698 }36993700 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3701 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3702 }37033704 async getPropertyPermissions(propertyKeys: string[] | null = null) {3705 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3706 }37073708 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3709 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3710 }37113712 async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3713 const api = this.helper.getApi();3714 const props = (await api.query.refungible.tokenProperties(this.collectionId, tokenId)).toJSON();37153716 return (props! as any).consumedSpace;3717 }37183719 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3720 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3721 }37223723 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3724 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3725 }37263727 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3728 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3729 }37303731 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3732 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3733 }37343735 async mintToken(signer: TSigner, pieces = 1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3736 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3737 }37383739 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3740 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3741 }37423743 async burnToken(signer: TSigner, tokenId: number, amount=1n) {3744 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3745 }37463747 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {3748 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3749 }37503751 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3752 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3753 }37543755 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3756 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3757 }37583759 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3760 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3761 }37623763 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3764 return await this.helper.rft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3765 }37663767 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3768 return await this.helper.rft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3769 }37703771 scheduleAt<T extends UniqueHelper>(3772 executionBlockNumber: number,3773 options: ISchedulerOptions = {},3774 ) {3775 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3776 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3777 }37783779 scheduleAfter<T extends UniqueHelper>(3780 blocksBeforeExecution: number,3781 options: ISchedulerOptions = {},3782 ) {3783 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3784 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3785 }37863787 getSudo<T extends UniqueHelper>() {3788 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3789 }3790}379137923793export class UniqueFTCollection extends UniqueBaseCollection {3794 async getBalance(addressObj: ICrossAccountId) {3795 return await this.helper.ft.getBalance(this.collectionId, addressObj);3796 }37973798 async getTotalPieces() {3799 return await this.helper.ft.getTotalPieces(this.collectionId);3800 }38013802 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3803 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3804 }38053806 async getTop10Owners() {3807 return await this.helper.ft.getTop10Owners(this.collectionId);3808 }38093810 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3811 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3812 }38133814 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3815 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3816 }38173818 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3819 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3820 }38213822 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3823 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3824 }38253826 async burnTokens(signer: TSigner, amount=1n) {3827 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3828 }38293830 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3831 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3832 }38333834 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3835 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3836 }38373838 scheduleAt<T extends UniqueHelper>(3839 executionBlockNumber: number,3840 options: ISchedulerOptions = {},3841 ) {3842 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3843 return new UniqueFTCollection(this.collectionId, scheduledHelper);3844 }38453846 scheduleAfter<T extends UniqueHelper>(3847 blocksBeforeExecution: number,3848 options: ISchedulerOptions = {},3849 ) {3850 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3851 return new UniqueFTCollection(this.collectionId, scheduledHelper);3852 }38533854 getSudo<T extends UniqueHelper>() {3855 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3856 }3857}385838593860export class UniqueBaseToken {3861 collection: UniqueNFTCollection | UniqueRFTCollection;3862 collectionId: number;3863 tokenId: number;38643865 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3866 this.collection = collection;3867 this.collectionId = collection.collectionId;3868 this.tokenId = tokenId;3869 }38703871 async getNextSponsored(addressObj: ICrossAccountId) {3872 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3873 }38743875 async getProperties(propertyKeys?: string[] | null) {3876 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3877 }38783879 async getTokenPropertiesConsumedSpace() {3880 return await this.collection.getTokenPropertiesConsumedSpace(this.tokenId);3881 }38823883 async setProperties(signer: TSigner, properties: IProperty[]) {3884 return await this.collection.setTokenProperties(signer, this.tokenId, properties);3885 }38863887 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3888 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3889 }38903891 async doesExist() {3892 return await this.collection.doesTokenExist(this.tokenId);3893 }38943895 nestingAccount() {3896 return this.collection.helper.util.getTokenAccount(this);3897 }38983899 scheduleAt<T extends UniqueHelper>(3900 executionBlockNumber: number,3901 options: ISchedulerOptions = {},3902 ) {3903 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3904 return new UniqueBaseToken(this.tokenId, scheduledCollection);3905 }39063907 scheduleAfter<T extends UniqueHelper>(3908 blocksBeforeExecution: number,3909 options: ISchedulerOptions = {},3910 ) {3911 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3912 return new UniqueBaseToken(this.tokenId, scheduledCollection);3913 }39143915 getSudo<T extends UniqueHelper>() {3916 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3917 }3918}391939203921export class UniqueNFToken extends UniqueBaseToken {3922 collection: UniqueNFTCollection;39233924 constructor(tokenId: number, collection: UniqueNFTCollection) {3925 super(tokenId, collection);3926 this.collection = collection;3927 }39283929 async getData(blockHashAt?: string) {3930 return await this.collection.getToken(this.tokenId, blockHashAt);3931 }39323933 async getOwner(blockHashAt?: string) {3934 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3935 }39363937 async getTopmostOwner(blockHashAt?: string) {3938 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3939 }39403941 async getChildren(blockHashAt?: string) {3942 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3943 }39443945 async nest(signer: TSigner, toTokenObj: IToken) {3946 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3947 }39483949 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3950 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3951 }39523953 async transfer(signer: TSigner, addressObj: ICrossAccountId) {3954 return await this.collection.transferToken(signer, this.tokenId, addressObj);3955 }39563957 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3958 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3959 }39603961 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3962 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3963 }39643965 async isApproved(toAddressObj: ICrossAccountId) {3966 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3967 }39683969 async burn(signer: TSigner) {3970 return await this.collection.burnToken(signer, this.tokenId);3971 }39723973 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3974 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3975 }39763977 scheduleAt<T extends UniqueHelper>(3978 executionBlockNumber: number,3979 options: ISchedulerOptions = {},3980 ) {3981 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3982 return new UniqueNFToken(this.tokenId, scheduledCollection);3983 }39843985 scheduleAfter<T extends UniqueHelper>(3986 blocksBeforeExecution: number,3987 options: ISchedulerOptions = {},3988 ) {3989 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3990 return new UniqueNFToken(this.tokenId, scheduledCollection);3991 }39923993 getSudo<T extends UniqueHelper>() {3994 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3995 }3996}39973998export class UniqueRFToken extends UniqueBaseToken {3999 collection: UniqueRFTCollection;40004001 constructor(tokenId: number, collection: UniqueRFTCollection) {4002 super(tokenId, collection);4003 this.collection = collection;4004 }40054006 async getData(blockHashAt?: string) {4007 return await this.collection.getToken(this.tokenId, blockHashAt);4008 }40094010 async getOwner(blockHashAt?: string) {4011 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);4012 }40134014 async getTop10Owners() {4015 return await this.collection.getTop10TokenOwners(this.tokenId);4016 }40174018 async getTopmostOwner(blockHashAt?: string) {4019 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);4020 }40214022 async nest(signer: TSigner, toTokenObj: IToken) {4023 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);4024 }40254026 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {4027 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);4028 }40294030 async getBalance(addressObj: ICrossAccountId) {4031 return await this.collection.getTokenBalance(this.tokenId, addressObj);4032 }40334034 async getTotalPieces() {4035 return await this.collection.getTokenTotalPieces(this.tokenId);4036 }40374038 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {4039 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);4040 }40414042 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {4043 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);4044 }40454046 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {4047 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);4048 }40494050 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {4051 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);4052 }40534054 async repartition(signer: TSigner, amount: bigint) {4055 return await this.collection.repartitionToken(signer, this.tokenId, amount);4056 }40574058 async burn(signer: TSigner, amount=1n) {4059 return await this.collection.burnToken(signer, this.tokenId, amount);4060 }40614062 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {4063 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);4064 }40654066 scheduleAt<T extends UniqueHelper>(4067 executionBlockNumber: number,4068 options: ISchedulerOptions = {},4069 ) {4070 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);4071 return new UniqueRFToken(this.tokenId, scheduledCollection);4072 }40734074 scheduleAfter<T extends UniqueHelper>(4075 blocksBeforeExecution: number,4076 options: ISchedulerOptions = {},4077 ) {4078 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);4079 return new UniqueRFToken(this.tokenId, scheduledCollection);4080 }40814082 getSudo<T extends UniqueHelper>() {4083 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());4084 }4085}tests/src/xcm/xcmQuartz.test.tsdiffbeforeafterboth--- a/tests/src/xcm/xcmQuartz.test.ts
+++ b/tests/src/xcm/xcmQuartz.test.ts
@@ -15,7 +15,6 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
import {IKeyringPair} from '@polkadot/types/types';
-import {blake2AsHex} from '@polkadot/util-crypto';
import config from '../config';
import {XcmV2TraitsError} from '../interfaces';
import {itSub, expect, describeXCM, usingPlaygrounds, usingKaruraPlaygrounds, usingRelayPlaygrounds, usingMoonriverPlaygrounds, usingStateminePlaygrounds, usingShidenPlaygrounds} from '../util';
@@ -680,11 +679,13 @@
});
const maxWaitBlocks = 3;
+ const outcomeField = 1;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ const xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -738,7 +739,7 @@
},
};
- const maliciousXcmProgram = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
targetAccount.addressRaw,
{
Concrete: {
@@ -753,16 +754,55 @@
testAmount,
);
+ const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ testAmount,
+ );
+
+ // Try to trick Quartz using full QTZ identification
await usingKaruraPlaygrounds(karuraUrl, async (helper) => {
- await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgram);
+ await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramFullId);
});
const maxWaitBlocks = 3;
+ const outcomeField = 1;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ let xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isUntrustedReserveLocation,
+ 'The XCM error should be \'isUntrustedReserveLocation\'',
+ ).to.be.true;
+
+ let accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
+
+ // Try to trick Quartz using shortened QTZ identification
+ await usingKaruraPlaygrounds(karuraUrl, async (helper) => {
+ await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramHereId);
+ });
+
+ xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -775,7 +815,7 @@
'The XCM error should be \'isUntrustedReserveLocation\'',
).to.be.true;
- const accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ accountBalance = await helper.balance.getSubstrate(targetAccount.address);
expect(accountBalance).to.be.equal(0n);
});
});
@@ -845,11 +885,13 @@
const expectFailedToTransact = async (network: string, helper: DevUniqueHelper) => {
const maxWaitBlocks = 3;
+ const outcomeField = 1;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ const xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -918,7 +960,7 @@
describeXCM('[XCM] Integration test: Exchanging QTZ with Moonriver', () => {
// Quartz constants
- let quartzDonor: IKeyringPair;
+ let alice: IKeyringPair;
let quartzAssetLocation;
let randomAccountQuartz: IKeyringPair;
@@ -927,11 +969,6 @@
// Moonriver constants
let assetId: string;
- const councilVotingThreshold = 2;
- const technicalCommitteeThreshold = 2;
- const votingPeriod = 3;
- const delayPeriod = 0;
-
const quartzAssetMetadata = {
name: 'xcQuartz',
symbol: 'xcQTZ',
@@ -952,13 +989,12 @@
before(async () => {
await usingPlaygrounds(async (helper, privateKey) => {
- quartzDonor = await privateKey('//Alice');
- [randomAccountQuartz] = await helper.arrange.createAccounts([0n], quartzDonor);
+ alice = await privateKey('//Alice');
+ [randomAccountQuartz] = await helper.arrange.createAccounts([0n], alice);
balanceForeignQtzTokenInit = 0n;
// Set the default version to wrap the first message to other chains.
- const alice = quartzDonor;
await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
});
@@ -994,84 +1030,13 @@
unitsPerSecond,
numAssetsWeightHint,
});
- const proposalHash = blake2AsHex(encodedProposal);
console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);
- console.log('Encoded length %d', encodedProposal.length);
- console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);
- // >>> Note motion preimage >>>
- console.log('Note motion preimage.......');
- await helper.democracy.notePreimage(baltatharAccount, encodedProposal);
- console.log('Note motion preimage.......DONE');
- // <<< Note motion preimage <<<
-
- // >>> Propose external motion through council >>>
- console.log('Propose external motion through council.......');
- const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});
- const encodedMotion = externalMotion?.method.toHex() || '';
- const motionHash = blake2AsHex(encodedMotion);
- console.log('Motion hash is %s', motionHash);
-
- await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);
-
- const councilProposalIdx = await helper.collective.council.proposalCount() - 1;
- await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);
- await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);
-
- await helper.collective.council.close(
- dorothyAccount,
- motionHash,
- councilProposalIdx,
- {
- refTime: 1_000_000_000,
- proofSize: 1_000_000,
- },
- externalMotion.encodedLength,
- );
- console.log('Propose external motion through council.......DONE');
- // <<< Propose external motion through council <<<
-
- // >>> Fast track proposal through technical committee >>>
- console.log('Fast track proposal through technical committee.......');
- const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);
- const encodedFastTrack = fastTrack?.method.toHex() || '';
- const fastTrackHash = blake2AsHex(encodedFastTrack);
- console.log('FastTrack hash is %s', fastTrackHash);
-
- await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);
-
- const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;
- await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);
- await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);
-
- await helper.collective.techCommittee.close(
- baltatharAccount,
- fastTrackHash,
- techProposalIdx,
- {
- refTime: 1_000_000_000,
- proofSize: 1_000_000,
- },
- fastTrack.encodedLength,
- );
- console.log('Fast track proposal through technical committee.......DONE');
- // <<< Fast track proposal through technical committee <<<
-
- // >>> Referendum voting >>>
- console.log('Referendum voting.......');
- await helper.democracy.referendumVote(dorothyAccount, 0, {
- balance: 10_000_000_000_000_000_000n,
- vote: {aye: true, conviction: 1},
- });
- console.log('Referendum voting.......DONE');
- // <<< Referendum voting <<<
+ await helper.fastDemocracy.executeProposal('register QTZ foreign asset', encodedProposal);
// >>> Acquire Quartz AssetId Info on Moonriver >>>
console.log('Acquire Quartz AssetId Info on Moonriver.......');
-
- // Wait for the democracy execute
- await helper.wait.newBlocks(5);
assetId = (await helper.assetManager.assetTypeId(quartzAssetLocation)).toString();
@@ -1089,7 +1054,7 @@
});
await usingPlaygrounds(async (helper) => {
- await helper.balance.transferToSubstrate(quartzDonor, randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);
+ await helper.balance.transferToSubstrate(alice, randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);
balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccountQuartz.address);
});
});
@@ -1197,14 +1162,197 @@
expect(qtzFees == 0n).to.be.true;
});
- // eslint-disable-next-line require-await
- itSub.skip('Moonriver can send only up to its balance', async ({helper}) => {
- throw Error('Not yet implemented');
+ itSub('Moonriver can send only up to its balance', async ({helper}) => {
+ // set Moonriver's sovereign account's balance
+ const moonriverBalance = 10000n * (10n ** QTZ_DECIMALS);
+ const moonriverSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONRIVER_CHAIN);
+ await helper.getSudo().balance.setBalanceSubstrate(alice, moonriverSovereignAccount, moonriverBalance);
+
+ const moreThanMoonriverHas = moonriverBalance * 2n;
+
+ let targetAccountBalance = 0n;
+ const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);
+
+ const quartzMultilocation = {
+ V1: {
+ parents: 1,
+ interior: {
+ X1: {Parachain: QUARTZ_CHAIN},
+ },
+ },
+ };
+
+ const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ moreThanMoonriverHas,
+ );
+
+ // Try to trick Quartz
+ await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgram]);
+
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal('try to spend more QTZ than Moonriver has', batchCall);
+ });
+
+ const maxWaitBlocks = 3;
+ const outcomeField = 1;
+
+ const xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isFailedToTransactAsset,
+ 'The XCM error should be \'FailedToTransactAsset\'',
+ ).to.be.true;
+
+ targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(targetAccountBalance).to.be.equal(0n);
+
+ // But Moonriver still can send the correct amount
+ const validTransferAmount = moonriverBalance / 2n;
+ const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ validTransferAmount,
+ );
+
+ await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, validXcmProgram]);
+
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal('Spend the correct amount of QTZ', batchCall);
+ });
+
+ await helper.wait.newBlocks(maxWaitBlocks);
+
+ targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(targetAccountBalance).to.be.equal(validTransferAmount);
});
- // eslint-disable-next-line require-await
- itSub.skip('Should not accept reserve transfer of QTZ from Moonriver', async ({helper}) => {
- throw Error('Not yet implemented');
+ itSub('Should not accept reserve transfer of QTZ from Moonriver', async ({helper}) => {
+ const testAmount = 10_000n * (10n ** QTZ_DECIMALS);
+ const [targetAccount] = await helper.arrange.createAccounts([0n], alice);
+
+ const quartzMultilocation = {
+ V1: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: QUARTZ_CHAIN,
+ },
+ },
+ },
+ };
+
+ const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: {
+ X1: {
+ Parachain: QUARTZ_CHAIN,
+ },
+ },
+ },
+ },
+ testAmount,
+ );
+
+ const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ testAmount,
+ );
+
+ // Try to trick Quartz using full QTZ identification
+ await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgramFullId]);
+
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal('try to act like a reserve location for QTZ using path asset identification', batchCall);
+ });
+
+ const maxWaitBlocks = 3;
+ const outcomeField = 1;
+
+ let xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isUntrustedReserveLocation,
+ 'The XCM error should be \'isUntrustedReserveLocation\'',
+ ).to.be.true;
+
+ let accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
+
+ // Try to trick Quartz using shortened QTZ identification
+ await usingMoonriverPlaygrounds(moonriverUrl, async (helper) => {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [quartzMultilocation, maliciousXcmProgramHereId]);
+
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal('try to act like a reserve location for QTZ using "here" asset identification', batchCall);
+ });
+
+ xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isUntrustedReserveLocation,
+ 'The XCM error should be \'isUntrustedReserveLocation\'',
+ ).to.be.true;
+
+ accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
});
});
@@ -1456,11 +1604,13 @@
});
const maxWaitBlocks = 3;
+ const outcomeField = 1;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ const xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -1514,7 +1664,7 @@
},
};
- const maliciousXcmProgram = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
targetAccount.addressRaw,
{
Concrete: {
@@ -1529,16 +1679,55 @@
testAmount,
);
+ const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ testAmount,
+ );
+
+ // Try to trick Quartz using full QTZ identification
await usingShidenPlaygrounds(shidenUrl, async (helper) => {
- await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgram);
+ await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramFullId);
});
const maxWaitBlocks = 3;
+ const outcomeField = 1;
+
+ let xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isUntrustedReserveLocation,
+ 'The XCM error should be \'isUntrustedReserveLocation\'',
+ ).to.be.true;
+
+ let accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
+
+ // Try to trick Quartz using shortened QTZ identification
+ await usingShidenPlaygrounds(shidenUrl, async (helper) => {
+ await helper.getSudo().xcm.send(alice, quartzMultilocation, maliciousXcmProgramHereId);
+ });
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -1551,7 +1740,7 @@
'The XCM error should be \'isUntrustedReserveLocation\'',
).to.be.true;
- const accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ accountBalance = await helper.balance.getSubstrate(targetAccount.address);
expect(accountBalance).to.be.equal(0n);
});
});
tests/src/xcm/xcmUnique.test.tsdiffbeforeafterboth--- a/tests/src/xcm/xcmUnique.test.ts
+++ b/tests/src/xcm/xcmUnique.test.ts
@@ -15,7 +15,6 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
import {IKeyringPair} from '@polkadot/types/types';
-import {blake2AsHex} from '@polkadot/util-crypto';
import config from '../config';
import {XcmV2TraitsError} from '../interfaces';
import {itSub, expect, describeXCM, usingPlaygrounds, usingAcalaPlaygrounds, usingRelayPlaygrounds, usingMoonbeamPlaygrounds, usingStatemintPlaygrounds, usingAstarPlaygrounds} from '../util';
@@ -682,11 +681,13 @@
});
const maxWaitBlocks = 3;
+ const outcomeField = 1;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ const xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -725,7 +726,7 @@
expect(targetAccountBalance).to.be.equal(validTransferAmount);
});
- itSub('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {
+ itSub.only('Should not accept reserve transfer of UNQ from Acala', async ({helper}) => {
const testAmount = 10_000n * (10n ** UNQ_DECIMALS);
const [targetAccount] = await helper.arrange.createAccounts([0n], alice);
@@ -740,7 +741,7 @@
},
};
- const maliciousXcmProgram = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
targetAccount.addressRaw,
{
Concrete: {
@@ -755,16 +756,30 @@
testAmount,
);
+ const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ testAmount,
+ );
+
+ // Try to trick Unique using full UNQ identification
await usingAcalaPlaygrounds(acalaUrl, async (helper) => {
- await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);
+ await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);
});
const maxWaitBlocks = 3;
+ const outcomeField = 1;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ let xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -777,8 +792,33 @@
'The XCM error should be \'isUntrustedReserveLocation\'',
).to.be.true;
- const accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ let accountBalance = await helper.balance.getSubstrate(targetAccount.address);
expect(accountBalance).to.be.equal(0n);
+
+ // Try to trick Unique using shortened UNQ identification
+ await usingAcalaPlaygrounds(acalaUrl, async (helper) => {
+ await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);
+ });
+
+ xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isUntrustedReserveLocation,
+ 'The XCM error should be \'isUntrustedReserveLocation\'',
+ ).to.be.true;
+
+ accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
});
});
@@ -847,11 +887,13 @@
const expectFailedToTransact = async (network: string, helper: DevUniqueHelper) => {
const maxWaitBlocks = 3;
+ const outcomeField = 1;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ const xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -920,7 +962,7 @@
describeXCM('[XCM] Integration test: Exchanging UNQ with Moonbeam', () => {
// Unique constants
- let uniqueDonor: IKeyringPair;
+ let alice: IKeyringPair;
let uniqueAssetLocation;
let randomAccountUnique: IKeyringPair;
@@ -929,11 +971,6 @@
// Moonbeam constants
let assetId: string;
- const councilVotingThreshold = 2;
- const technicalCommitteeThreshold = 2;
- const votingPeriod = 3;
- const delayPeriod = 0;
-
const uniqueAssetMetadata = {
name: 'xcUnique',
symbol: 'xcUNQ',
@@ -954,13 +991,12 @@
before(async () => {
await usingPlaygrounds(async (helper, privateKey) => {
- uniqueDonor = await privateKey('//Alice');
- [randomAccountUnique] = await helper.arrange.createAccounts([0n], uniqueDonor);
+ alice = await privateKey('//Alice');
+ [randomAccountUnique] = await helper.arrange.createAccounts([0n], alice);
balanceForeignUnqTokenInit = 0n;
// Set the default version to wrap the first message to other chains.
- const alice = uniqueDonor;
await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
});
@@ -996,84 +1032,13 @@
unitsPerSecond,
numAssetsWeightHint,
});
- const proposalHash = blake2AsHex(encodedProposal);
console.log('Encoded proposal for registerForeignAsset & setAssetUnitsPerSecond is %s', encodedProposal);
- console.log('Encoded length %d', encodedProposal.length);
- console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);
-
- // >>> Note motion preimage >>>
- console.log('Note motion preimage.......');
- await helper.democracy.notePreimage(baltatharAccount, encodedProposal);
- console.log('Note motion preimage.......DONE');
- // <<< Note motion preimage <<<
-
- // >>> Propose external motion through council >>>
- console.log('Propose external motion through council.......');
- const externalMotion = helper.democracy.externalProposeMajority({Legacy: proposalHash});
- const encodedMotion = externalMotion?.method.toHex() || '';
- const motionHash = blake2AsHex(encodedMotion);
- console.log('Motion hash is %s', motionHash);
-
- await helper.collective.council.propose(baltatharAccount, councilVotingThreshold, externalMotion, externalMotion.encodedLength);
-
- const councilProposalIdx = await helper.collective.council.proposalCount() - 1;
- await helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);
- await helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);
-
- await helper.collective.council.close(
- dorothyAccount,
- motionHash,
- councilProposalIdx,
- {
- refTime: 1_000_000_000,
- proofSize: 1_000_000,
- },
- externalMotion.encodedLength,
- );
- console.log('Propose external motion through council.......DONE');
- // <<< Propose external motion through council <<<
- // >>> Fast track proposal through technical committee >>>
- console.log('Fast track proposal through technical committee.......');
- const fastTrack = helper.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);
- const encodedFastTrack = fastTrack?.method.toHex() || '';
- const fastTrackHash = blake2AsHex(encodedFastTrack);
- console.log('FastTrack hash is %s', fastTrackHash);
-
- await helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);
-
- const techProposalIdx = await helper.collective.techCommittee.proposalCount() - 1;
- await helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);
- await helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);
-
- await helper.collective.techCommittee.close(
- baltatharAccount,
- fastTrackHash,
- techProposalIdx,
- {
- refTime: 1_000_000_000,
- proofSize: 1_000_000,
- },
- fastTrack.encodedLength,
- );
- console.log('Fast track proposal through technical committee.......DONE');
- // <<< Fast track proposal through technical committee <<<
+ await helper.fastDemocracy.executeProposal('register UNQ foreign asset', encodedProposal);
- // >>> Referendum voting >>>
- console.log('Referendum voting.......');
- await helper.democracy.referendumVote(dorothyAccount, 0, {
- balance: 10_000_000_000_000_000_000n,
- vote: {aye: true, conviction: 1},
- });
- console.log('Referendum voting.......DONE');
- // <<< Referendum voting <<<
-
// >>> Acquire Unique AssetId Info on Moonbeam >>>
console.log('Acquire Unique AssetId Info on Moonbeam.......');
-
- // Wait for the democracy execute
- await helper.wait.newBlocks(5);
assetId = (await helper.assetManager.assetTypeId(uniqueAssetLocation)).toString();
@@ -1091,7 +1056,7 @@
});
await usingPlaygrounds(async (helper) => {
- await helper.balance.transferToSubstrate(uniqueDonor, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);
+ await helper.balance.transferToSubstrate(alice, randomAccountUnique.address, 10n * TRANSFER_AMOUNT);
balanceUniqueTokenInit = await helper.balance.getSubstrate(randomAccountUnique.address);
});
});
@@ -1200,14 +1165,197 @@
expect(unqFees == 0n).to.be.true;
});
- // eslint-disable-next-line require-await
- itSub.skip('Moonbeam can send only up to its balance', async ({helper}) => {
- throw Error('Not yet implemented');
+ itSub('Moonbeam can send only up to its balance', async ({helper}) => {
+ // set Moonbeam's sovereign account's balance
+ const moonbeamBalance = 10000n * (10n ** UNQ_DECIMALS);
+ const moonbeamSovereignAccount = helper.address.paraSiblingSovereignAccount(MOONBEAM_CHAIN);
+ await helper.getSudo().balance.setBalanceSubstrate(alice, moonbeamSovereignAccount, moonbeamBalance);
+
+ const moreThanMoonbeamHas = moonbeamBalance * 2n;
+
+ let targetAccountBalance = 0n;
+ const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);
+
+ const uniqueMultilocation = {
+ V1: {
+ parents: 1,
+ interior: {
+ X1: {Parachain: UNIQUE_CHAIN},
+ },
+ },
+ };
+
+ const maliciousXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ moreThanMoonbeamHas,
+ );
+
+ // Try to trick Unique
+ await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgram]);
+
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal('try to spend more UNQ than Moonbeam has', batchCall);
+ });
+
+ const maxWaitBlocks = 3;
+ const outcomeField = 1;
+
+ const xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isFailedToTransactAsset,
+ 'The XCM error should be \'FailedToTransactAsset\'',
+ ).to.be.true;
+
+ targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(targetAccountBalance).to.be.equal(0n);
+
+ // But Moonbeam still can send the correct amount
+ const validTransferAmount = moonbeamBalance / 2n;
+ const validXcmProgram = helper.arrange.makeXcmProgramWithdrawDeposit(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ validTransferAmount,
+ );
+
+ await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, validXcmProgram]);
+
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal('Spend the correct amount of UNQ', batchCall);
+ });
+
+ await helper.wait.newBlocks(maxWaitBlocks);
+
+ targetAccountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(targetAccountBalance).to.be.equal(validTransferAmount);
});
- // eslint-disable-next-line require-await
- itSub.skip('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {
- throw Error('Not yet implemented');
+ itSub.only('Should not accept reserve transfer of UNQ from Moonbeam', async ({helper}) => {
+ const testAmount = 10_000n * (10n ** UNQ_DECIMALS);
+ const [targetAccount] = await helper.arrange.createAccounts([0n], alice);
+
+ const uniqueMultilocation = {
+ V1: {
+ parents: 1,
+ interior: {
+ X1: {
+ Parachain: UNIQUE_CHAIN,
+ },
+ },
+ },
+ };
+
+ const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: {
+ X1: {
+ Parachain: UNIQUE_CHAIN,
+ },
+ },
+ },
+ },
+ testAmount,
+ );
+
+ const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ testAmount,
+ );
+
+ // Try to trick Unique using full UNQ identification
+ await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramFullId]);
+
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using path asset identification', batchCall);
+ });
+
+ const maxWaitBlocks = 3;
+ const outcomeField = 1;
+
+ let xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isUntrustedReserveLocation,
+ 'The XCM error should be \'isUntrustedReserveLocation\'',
+ ).to.be.true;
+
+ let accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
+
+ // Try to trick Unique using shortened UNQ identification
+ await usingMoonbeamPlaygrounds(moonbeamUrl, async (helper) => {
+ const xcmSend = helper.constructApiCall('api.tx.polkadotXcm.send', [uniqueMultilocation, maliciousXcmProgramHereId]);
+
+ // Needed to bypass the call filter.
+ const batchCall = helper.encodeApiCall('api.tx.utility.batch', [[xcmSend]]);
+ await helper.fastDemocracy.executeProposal('try to act like a reserve location for UNQ using "here" asset identification', batchCall);
+ });
+
+ xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isUntrustedReserveLocation,
+ 'The XCM error should be \'isUntrustedReserveLocation\'',
+ ).to.be.true;
+
+ accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
});
});
@@ -1215,14 +1363,14 @@
let alice: IKeyringPair;
let randomAccount: IKeyringPair;
- const UNQ_ASSET_ID_ON_SHIDEN = 1;
- const UNQ_MINIMAL_BALANCE_ON_SHIDEN = 1n;
+ const UNQ_ASSET_ID_ON_ASTAR = 1;
+ const UNQ_MINIMAL_BALANCE_ON_ASTAR = 1n;
// Unique -> Astar
- const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Shiden.
+ const astarInitialBalance = 1n * (10n ** ASTAR_DECIMALS); // 1 ASTR, existential deposit required to actually create the account on Astar.
const unitsPerSecond = 228_000_000_000n; // This is Phala's value. What will be ours?
const unqToAstarTransferred = 10n * (10n ** UNQ_DECIMALS); // 10 UNQ
- const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Shiden takes a commision in foreign tokens
+ const unqToAstarArrived = 9_999_999_999_088_000_000n; // 9.999 ... UNQ, Astar takes a commision in foreign tokens
// Astar -> Unique
const unqFromAstarTransfered = 5n * (10n ** UNQ_DECIMALS); // 5 UNQ
@@ -1245,14 +1393,14 @@
// TODO update metadata with values from production
await helper.assets.create(
alice,
- UNQ_ASSET_ID_ON_SHIDEN,
+ UNQ_ASSET_ID_ON_ASTAR,
alice.address,
- UNQ_MINIMAL_BALANCE_ON_SHIDEN,
+ UNQ_MINIMAL_BALANCE_ON_ASTAR,
);
await helper.assets.setMetadata(
alice,
- UNQ_ASSET_ID_ON_SHIDEN,
+ UNQ_ASSET_ID_ON_ASTAR,
'Cross chain UNQ',
'xcUNQ',
Number(UNQ_DECIMALS),
@@ -1270,7 +1418,7 @@
},
};
- await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_SHIDEN]);
+ await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.registerAssetLocation', [assetLocation, UNQ_ASSET_ID_ON_ASTAR]);
console.log('3. Set UNQ payment for XCM execution on Astar');
await helper.getSudo().executeExtrinsic(alice, 'api.tx.xcAssetConfig.setAssetUnitsPerSecond', [assetLocation, unitsPerSecond]);
@@ -1337,7 +1485,7 @@
await usingAstarPlaygrounds(astarUrl, async (helper) => {
await helper.wait.newBlocks(3);
- const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_SHIDEN, randomAccount.address);
+ const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);
const astarBalance = await helper.balance.getSubstrate(randomAccount.address);
console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);
@@ -1405,7 +1553,7 @@
// this is non-standard polkadotXcm extension for Astar only. It calls InitiateReserveWithdraw
await helper.executeExtrinsic(randomAccount, 'api.tx.polkadotXcm.reserveWithdrawAssets', [destination, beneficiary, assets, feeAssetItem]);
- const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_SHIDEN, randomAccount.address);
+ const xcUNQbalance = await helper.assets.account(UNQ_ASSET_ID_ON_ASTAR, randomAccount.address);
const balanceAstar = await helper.balance.getSubstrate(randomAccount.address);
console.log(`xcUNQ balance on Astar after XCM is: ${xcUNQbalance}`);
@@ -1427,7 +1575,7 @@
const astarSovereignAccount = helper.address.paraSiblingSovereignAccount(ASTAR_CHAIN);
await helper.getSudo().balance.setBalanceSubstrate(alice, astarSovereignAccount, astarBalance);
- const moreThanShidenHas = astarBalance * 2n;
+ const moreThanAstarHas = astarBalance * 2n;
let targetAccountBalance = 0n;
const [targetAccount] = await helper.arrange.createAccounts([targetAccountBalance], alice);
@@ -1449,7 +1597,7 @@
interior: 'Here',
},
},
- moreThanShidenHas,
+ moreThanAstarHas,
);
// Try to trick Unique
@@ -1458,11 +1606,13 @@
});
const maxWaitBlocks = 3;
+ const outcomeField = 1;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ const xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -1501,7 +1651,7 @@
expect(targetAccountBalance).to.be.equal(validTransferAmount);
});
- itSub('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {
+ itSub.only('Should not accept reserve transfer of UNQ from Astar', async ({helper}) => {
const testAmount = 10_000n * (10n ** UNQ_DECIMALS);
const [targetAccount] = await helper.arrange.createAccounts([0n], alice);
@@ -1516,7 +1666,7 @@
},
};
- const maliciousXcmProgram = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ const maliciousXcmProgramFullId = helper.arrange.makeXcmProgramReserveAssetDeposited(
targetAccount.addressRaw,
{
Concrete: {
@@ -1531,16 +1681,55 @@
testAmount,
);
+ const maliciousXcmProgramHereId = helper.arrange.makeXcmProgramReserveAssetDeposited(
+ targetAccount.addressRaw,
+ {
+ Concrete: {
+ parents: 0,
+ interior: 'Here',
+ },
+ },
+ testAmount,
+ );
+
+ // Try to trick Unique using full UNQ identification
await usingAstarPlaygrounds(astarUrl, async (helper) => {
- await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgram);
+ await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramFullId);
});
const maxWaitBlocks = 3;
+ const outcomeField = 1;
+
+ let xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
+ maxWaitBlocks,
+ 'xcmpQueue',
+ 'Fail',
+ outcomeField,
+ );
+
+ expect(
+ xcmpQueueFailEvent != null,
+ '\'xcmpQueue.FailEvent\' event is expected',
+ ).to.be.true;
+
+ expect(
+ xcmpQueueFailEvent!.isUntrustedReserveLocation,
+ 'The XCM error should be \'isUntrustedReserveLocation\'',
+ ).to.be.true;
- const xcmpQueueFailEvent = await helper.wait.eventOutcome<XcmV2TraitsError>(
+ let accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ expect(accountBalance).to.be.equal(0n);
+
+ // Try to trick Unique using shortened UNQ identification
+ await usingAstarPlaygrounds(astarUrl, async (helper) => {
+ await helper.getSudo().xcm.send(alice, uniqueMultilocation, maliciousXcmProgramHereId);
+ });
+
+ xcmpQueueFailEvent = await helper.wait.eventData<XcmV2TraitsError>(
maxWaitBlocks,
'xcmpQueue',
'Fail',
+ outcomeField,
);
expect(
@@ -1553,7 +1742,7 @@
'The XCM error should be \'isUntrustedReserveLocation\'',
).to.be.true;
- const accountBalance = await helper.balance.getSubstrate(targetAccount.address);
+ accountBalance = await helper.balance.getSubstrate(targetAccount.address);
expect(accountBalance).to.be.equal(0n);
});