difftreelog
Fix test and improve throwing errors
in: master
3 files changed
tests/src/sub/appPromotion/appPromotion.test.tsdiffbeforeafterboth--- a/tests/src/sub/appPromotion/appPromotion.test.ts
+++ b/tests/src/sub/appPromotion/appPromotion.test.ts
@@ -247,7 +247,7 @@
// unstake has no effect if no stakes at all
testCase.method === 'unstakeAll'
? await helper.staking.unstakeAll(staker)
- : await helper.staking.unstakePartial(staker, 100n * nominal);
+ : await expect(helper.staking.unstakePartial(staker, 100n * nominal)).to.be.rejectedWith('Arithmetic: Underflow');
expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);
expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper
@@ -262,7 +262,7 @@
await helper.staking.unstakeAll(staker);
} else {
await helper.staking.unstakePartial(staker, 100n * nominal);
- await helper.staking.unstakePartial(staker, 100n * nominal);
+ await expect(helper.staking.unstakePartial(staker, 100n * nominal)).to.be.rejectedWith('Arithmetic: Underflow');
}
expect(await helper.staking.getStakesNumber({Substrate: staker.address})).to.eq(0);
tests/src/util/playgrounds/types.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/types.ts
+++ b/tests/src/util/playgrounds/types.ts
@@ -21,7 +21,7 @@
}[];
},
blockHash: string,
- moduleError?: string;
+ moduleError?: string | object;
}
export interface ISubscribeBlockEventsData {
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 {ApiInterfaceEvents, SignerOptions} from '@polkadot/api/types';10import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm, base58Encode, blake2AsU8a} from '@polkadot/util-crypto';11import {IKeyringPair} from '@polkadot/types/types';12import {hexToU8a} from '@polkadot/util/hex';13import {u8aConcat} from '@polkadot/util/u8a';14import {15 IApiListeners,16 IBlock,17 IEvent,18 IChainProperties,19 ICollectionCreationOptions,20 ICollectionLimits,21 ICollectionPermissions,22 ICrossAccountId,23 ICrossAccountIdLower,24 ILogger,25 INestingPermissions,26 IProperty,27 IStakingInfo,28 ISchedulerOptions,29 ISubstrateBalance,30 IToken,31 ITokenPropertyPermission,32 ITransactionResult,33 IUniqueHelperLog,34 TApiAllowedListeners,35 TEthereumAccount,36 TSigner,37 TSubstrateAccount,38 TNetworks,39 IForeignAssetMetadata,40 AcalaAssetMetadata,41 MoonbeamAssetInfo,42 DemocracyStandardAccountVote,43 IEthCrossAccountId,44} from './types';45import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';46import type {Vec} from '@polkadot/types-codec';47import {FrameSystemEventRecord} from '@polkadot/types/lookup';4849export class CrossAccountId implements ICrossAccountId {50 Substrate?: TSubstrateAccount;51 Ethereum?: TEthereumAccount;5253 constructor(account: ICrossAccountId) {54 if (account.Substrate) this.Substrate = account.Substrate;55 if (account.Ethereum) this.Ethereum = account.Ethereum;56 }5758 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {59 switch (domain) {60 case 'Substrate': return new CrossAccountId({Substrate: account.address});61 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();62 }63 }6465 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {66 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});67 }6869 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {70 return encodeAddress(decodeAddress(address), ss58Format);71 }7273 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {74 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});75 }7677 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {78 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);79 return this;80 }8182 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {83 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));84 }8586 toEthereum(): CrossAccountId {87 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});88 return this;89 }9091 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {92 return evmToAddress(address, ss58Format);93 }9495 toSubstrate(ss58Format?: number): CrossAccountId {96 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});97 return this;98 }99100 toLowerCase(): CrossAccountId {101 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();102 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();103 return this;104 }105}106107const nesting = {108 toChecksumAddress(address: string): string {109 if (typeof address === 'undefined') return '';110111 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);112113 address = address.toLowerCase().replace(/^0x/i,'');114 const addressHash = keccakAsHex(address).replace(/^0x/i,'');115 const checksumAddress = ['0x'];116117 for (let i = 0; i < address.length; i++) {118 // If ith character is 8 to f then make it uppercase119 if (parseInt(addressHash[i], 16) > 7) {120 checksumAddress.push(address[i].toUpperCase());121 } else {122 checksumAddress.push(address[i]);123 }124 }125 return checksumAddress.join('');126 },127 tokenIdToAddress(collectionId: number, tokenId: number) {128 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8,'0')}${tokenId.toString(16).padStart(8,'0')}`);129 },130};131132class UniqueUtil {133 static transactionStatus = {134 NOT_READY: 'NotReady',135 FAIL: 'Fail',136 SUCCESS: 'Success',137 };138139 static chainLogType = {140 EXTRINSIC: 'extrinsic',141 RPC: 'rpc',142 };143144 static getTokenAccount(token: IToken): CrossAccountId {145 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});146 }147148 static getTokenAddress(token: IToken): string {149 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);150 }151152 static getDefaultLogger(): ILogger {153 return {154 log(msg: any, level = 'INFO') {155 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));156 },157 level: {158 ERROR: 'ERROR',159 WARNING: 'WARNING',160 INFO: 'INFO',161 },162 };163 }164165 static vec2str(arr: string[] | number[]) {166 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');167 }168169 static str2vec(string: string) {170 if (typeof string !== 'string') return string;171 return Array.from(string).map(x => x.charCodeAt(0));172 }173174 static fromSeed(seed: string, ss58Format = 42) {175 const keyring = new Keyring({type: 'sr25519', ss58Format});176 return keyring.addFromUri(seed);177 }178179 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {180 if (creationResult.status !== this.transactionStatus.SUCCESS) {181 throw Error('Unable to create collection!');182 }183184 let collectionId = null;185 creationResult.result.events.forEach(({event: {data, method, section}}) => {186 if ((section === 'common') && (method === 'CollectionCreated')) {187 collectionId = parseInt(data[0].toString(), 10);188 }189 });190191 if (collectionId === null) {192 throw Error('No CollectionCreated event was found!');193 }194195 return collectionId;196 }197198 static extractTokensFromCreationResult(creationResult: ITransactionResult): {199 success: boolean,200 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],201 } {202 if (creationResult.status !== this.transactionStatus.SUCCESS) {203 throw Error('Unable to create tokens!');204 }205 let success = false;206 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];207 creationResult.result.events.forEach(({event: {data, method, section}}) => {208 if (method === 'ExtrinsicSuccess') {209 success = true;210 } else if ((section === 'common') && (method === 'ItemCreated')) {211 tokens.push({212 collectionId: parseInt(data[0].toString(), 10),213 tokenId: parseInt(data[1].toString(), 10),214 owner: data[2].toHuman(),215 amount: data[3].toBigInt(),216 });217 }218 });219 return {success, tokens};220 }221222 static extractTokensFromBurnResult(burnResult: ITransactionResult): {223 success: boolean,224 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],225 } {226 if (burnResult.status !== this.transactionStatus.SUCCESS) {227 throw Error('Unable to burn tokens!');228 }229 let success = false;230 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];231 burnResult.result.events.forEach(({event: {data, method, section}}) => {232 if (method === 'ExtrinsicSuccess') {233 success = true;234 } else if ((section === 'common') && (method === 'ItemDestroyed')) {235 tokens.push({236 collectionId: parseInt(data[0].toString(), 10),237 tokenId: parseInt(data[1].toString(), 10),238 owner: data[2].toHuman(),239 amount: data[3].toBigInt(),240 });241 }242 });243 return {success, tokens};244 }245246 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {247 let eventId = null;248 events.forEach(({event: {data, method, section}}) => {249 if ((section === expectedSection) && (method === expectedMethod)) {250 eventId = parseInt(data[0].toString(), 10);251 }252 });253254 if (eventId === null) {255 throw Error(`No ${expectedMethod} event was found!`);256 }257 return eventId === collectionId;258 }259260 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {261 const normalizeAddress = (address: string | ICrossAccountId) => {262 if(typeof address === 'string') return address;263 const obj = {} as any;264 Object.keys(address).forEach(k => {265 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];266 });267 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);268 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();269 return address;270 };271 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;272 events.forEach(({event: {data, method, section}}) => {273 if ((section === 'common') && (method === 'Transfer')) {274 const hData = (data as any).toJSON();275 transfer = {276 collectionId: hData[0],277 tokenId: hData[1],278 from: normalizeAddress(hData[2]),279 to: normalizeAddress(hData[3]),280 amount: BigInt(hData[4]),281 };282 }283 });284 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;285 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);286 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);287 isSuccess = isSuccess && amount === transfer.amount;288 return isSuccess;289 }290291 static bigIntToDecimals(number: bigint, decimals = 18) {292 const numberStr = number.toString();293 const dotPos = numberStr.length - decimals;294295 if (dotPos <= 0) {296 return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;297 } else {298 const intPart = numberStr.substring(0, dotPos);299 const fractPart = numberStr.substring(dotPos);300 return intPart + '.' + fractPart;301 }302 }303}304305class UniqueEventHelper {306 private static extractIndex(index: any): [number, number] | string {307 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];308 return index.toJSON();309 }310311 private static extractSub(data: any, subTypes: any): {[key: string]: any} {312 let obj: any = {};313 let index = 0;314315 if (data.entries) {316 for(const [key, value] of data.entries()) {317 obj[key] = this.extractData(value, subTypes[index]);318 index++;319 }320 } else obj = data.toJSON();321322 return obj;323 }324325 private static toHuman(data: any) {326 return data && data.toHuman ? data.toHuman() : `${data}`;327 }328329 private static extractData(data: any, type: any): any {330 if(!type) return this.toHuman(data);331 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();332 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();333 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);334 return this.toHuman(data);335 }336337 public static extractEvents(events: {event: any, phase: any}[]): IEvent[] {338 const parsedEvents: IEvent[] = [];339340 events.forEach((record) => {341 const {event, phase} = record;342 const types = event.typeDef;343344 const eventData: IEvent = {345 section: event.section.toString(),346 method: event.method.toString(),347 index: this.extractIndex(event.index),348 data: [],349 phase: phase.toJSON(),350 };351352 event.data.forEach((val: any, index: number) => {353 eventData.data.push(this.extractData(val, types[index]));354 });355356 parsedEvents.push(eventData);357 });358359 return parsedEvents;360 }361}362363export class ChainHelperBase {364 helperBase: any;365366 transactionStatus = UniqueUtil.transactionStatus;367 chainLogType = UniqueUtil.chainLogType;368 util: typeof UniqueUtil;369 eventHelper: typeof UniqueEventHelper;370 logger: ILogger;371 api: ApiPromise | null;372 forcedNetwork: TNetworks | null;373 network: TNetworks | null;374 wsEndpoint: string | null;375 chainLog: IUniqueHelperLog[];376 children: ChainHelperBase[];377 address: AddressGroup;378 chain: ChainGroup;379380 constructor(logger?: ILogger, helperBase?: any) {381 this.helperBase = helperBase;382383 this.util = UniqueUtil;384 this.eventHelper = UniqueEventHelper;385 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();386 this.logger = logger;387 this.api = null;388 this.forcedNetwork = null;389 this.network = null;390 this.wsEndpoint = null;391 this.chainLog = [];392 this.children = [];393 this.address = new AddressGroup(this);394 this.chain = new ChainGroup(this);395 }396397 clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {398 Object.setPrototypeOf(helperCls.prototype, this);399 const newHelper = new helperCls(this.logger, options);400401 newHelper.api = this.api;402 newHelper.network = this.network;403 newHelper.forceNetwork = this.forceNetwork;404405 this.children.push(newHelper);406407 return newHelper;408 }409410 getEndpoint(): string {411 if (this.wsEndpoint === null) throw Error('No connection was established');412 return this.wsEndpoint;413 }414415 getApi(): ApiPromise {416 if(this.api === null) throw Error('API not initialized');417 return this.api;418 }419420 async subscribeEvents(expectedEvents: {section: string, names: string[]}[]) {421 const collectedEvents: IEvent[] = [];422 const unsubscribe = await this.getApi().query.system.events((events: Vec<FrameSystemEventRecord>) => {423 const ievents = this.eventHelper.extractEvents(events);424 ievents.forEach((event) => {425 expectedEvents.forEach((e => {426 if (event.section === e.section && e.names.includes(event.method)) {427 collectedEvents.push(event);428 }429 }));430 });431 });432 return {unsubscribe: unsubscribe as any, collectedEvents};433 }434435 clearChainLog(): void {436 this.chainLog = [];437 }438439 forceNetwork(value: TNetworks): void {440 this.forcedNetwork = value;441 }442443 async connect(wsEndpoint: string, listeners?: IApiListeners) {444 if (this.api !== null) throw Error('Already connected');445 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);446 this.wsEndpoint = wsEndpoint;447 this.api = api;448 this.network = network;449 }450451 async disconnect() {452 for (const child of this.children) {453 child.clearApi();454 }455456 if (this.api === null) return;457 await this.api.disconnect();458 this.clearApi();459 }460461 clearApi() {462 this.api = null;463 this.network = null;464 }465466 static async detectNetwork(api: ApiPromise): Promise<TNetworks> {467 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;468 const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];469470 if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;471472 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;473 return 'opal';474 }475476 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {477 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});478 await api.isReady;479480 const network = await this.detectNetwork(api);481482 await api.disconnect();483484 return network;485 }486487 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{488 api: ApiPromise;489 network: TNetworks;490 }> {491 if(typeof network === 'undefined' || network === null) network = 'opal';492 const supportedRPC = {493 opal: {494 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,495 },496 quartz: {497 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,498 },499 unique: {500 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,501 },502 rococo: {},503 westend: {},504 moonbeam: {},505 moonriver: {},506 acala: {},507 karura: {},508 westmint: {},509 };510 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);511 const rpc = supportedRPC[network];512513 // TODO: investigate how to replace rpc in runtime514 // api._rpcCore.addUserInterfaces(rpc);515516 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});517518 await api.isReadyOrError;519520 if (typeof listeners === 'undefined') listeners = {};521 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {522 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;523 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);524 }525526 return {api, network};527 }528529 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {530 const {events, status} = data;531 if (status.isReady) {532 return this.transactionStatus.NOT_READY;533 }534 if (status.isBroadcast) {535 return this.transactionStatus.NOT_READY;536 }537 if (status.isInBlock || status.isFinalized) {538 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');539 if (errors.length > 0) {540 return this.transactionStatus.FAIL;541 }542 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {543 return this.transactionStatus.SUCCESS;544 }545 }546547 return this.transactionStatus.FAIL;548 }549550 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {551 const sign = (callback: any) => {552 if(options !== null) return transaction.signAndSend(sender, options, callback);553 return transaction.signAndSend(sender, callback);554 };555 // eslint-disable-next-line no-async-promise-executor556 return new Promise(async (resolve, reject) => {557 try {558 const unsub = await sign((result: any) => {559 const status = this.getTransactionStatus(result);560561 if (status === this.transactionStatus.SUCCESS) {562 this.logger.log(`${label} successful`);563 unsub();564 resolve({result, status, blockHash: result.status.asInBlock.toHuman()});565 } else if (status === this.transactionStatus.FAIL) {566 let moduleError = null;567568 if (result.hasOwnProperty('dispatchError')) {569 const dispatchError = result['dispatchError'];570571 if (dispatchError) {572 if (dispatchError.isModule) {573 const modErr = dispatchError.asModule;574 const errorMeta = dispatchError.registry.findMetaError(modErr);575576 moduleError = `${errorMeta.section}.${errorMeta.name}`;577 } else {578 moduleError = dispatchError.toHuman();579 }580 } else {581 this.logger.log(result, this.logger.level.ERROR);582 }583 }584585 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);586 unsub();587 reject({status, moduleError, result});588 }589 });590 } catch (e) {591 this.logger.log(e, this.logger.level.ERROR);592 reject(e);593 }594 });595 }596597 async signTransactionWithoutSending(signer: TSigner, tx: any) {598 const api = this.getApi();599 const signingInfo = await api.derive.tx.signingInfo(signer.address);600601 tx.sign(signer, {602 blockHash: api.genesisHash,603 genesisHash: api.genesisHash,604 runtimeVersion: api.runtimeVersion,605 nonce: signingInfo.nonce,606 });607608 return tx.toHex();609 }610611 async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {612 const api = this.getApi();613 const signingInfo = await api.derive.tx.signingInfo(signer.address);614615 // We need to sign the tx because616 // unsigned transactions does not have an inclusion fee617 tx.sign(signer, {618 blockHash: api.genesisHash,619 genesisHash: api.genesisHash,620 runtimeVersion: api.runtimeVersion,621 nonce: signingInfo.nonce,622 });623624 if (len === null) {625 return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;626 } else {627 return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;628 }629 }630631 constructApiCall(apiCall: string, params: any[]) {632 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);633 let call = this.getApi() as any;634 for(const part of apiCall.slice(4).split('.')) {635 call = call[part];636 if (!call) {637 const advice = part.includes('_') ? ' Looks like it needs to be converted to camel case.' : '';638 throw Error(`Function ${part} of api call ${apiCall} not found.${advice}`);639 }640 }641 return call(...params);642 }643644 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {645 if(this.api === null) throw Error('API not initialized');646 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);647648 const startTime = (new Date()).getTime();649 let result: ITransactionResult;650 let events: IEvent[] = [];651 try {652 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;653 events = this.eventHelper.extractEvents(result.result.events);654 const errorEvent = events.find((event) => event.method == 'ExecutedFailed' || event.method == 'CreatedFailed');655 if (errorEvent)656 throw Error(errorEvent.method + ': ' + extrinsic);657 }658 catch(e) {659 if(!(e as object).hasOwnProperty('status')) throw e;660 result = e as ITransactionResult;661 }662663 const endTime = (new Date()).getTime();664665 const log = {666 executedAt: endTime,667 executionTime: endTime - startTime,668 type: this.chainLogType.EXTRINSIC,669 status: result.status,670 call: extrinsic,671 signer: this.getSignerAddress(sender),672 params,673 } as IUniqueHelperLog;674675 if(result.status !== this.transactionStatus.SUCCESS) {676 if (result.moduleError) log.moduleError = result.moduleError;677 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;678 }679 if(events.length > 0) log.events = events;680681 this.chainLog.push(log);682683 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {684 if (result.moduleError) throw Error(`${result.moduleError}`);685 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));686 }687 return result;688 }689690 async callRpc(rpc: string, params?: any[]) {691 if(typeof params === 'undefined') params = [];692 if(this.api === null) throw Error('API not initialized');693 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);694695 const startTime = (new Date()).getTime();696 let result;697 let error = null;698 const log = {699 type: this.chainLogType.RPC,700 call: rpc,701 params,702 } as IUniqueHelperLog;703704 try {705 result = await this.constructApiCall(rpc, params);706 }707 catch(e) {708 error = e;709 }710711 const endTime = (new Date()).getTime();712713 log.executedAt = endTime;714 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';715 log.executionTime = endTime - startTime;716717 this.chainLog.push(log);718719 if(error !== null) throw error;720721 return result;722 }723724 getSignerAddress(signer: IKeyringPair | string): string {725 if(typeof signer === 'string') return signer;726 return signer.address;727 }728729 fetchAllPalletNames(): string[] {730 if(this.api === null) throw Error('API not initialized');731 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());732 }733734 fetchMissingPalletNames(requiredPallets: string[]): string[] {735 const palletNames = this.fetchAllPalletNames();736 return requiredPallets.filter(p => !palletNames.includes(p));737 }738}739740741class HelperGroup<T extends ChainHelperBase> {742 helper: T;743744 constructor(uniqueHelper: T) {745 this.helper = uniqueHelper;746 }747}748749750class CollectionGroup extends HelperGroup<UniqueHelper> {751 /**752 * Get number of blocks when sponsored transaction is available.753 *754 * @param collectionId ID of collection755 * @param tokenId ID of token756 * @param addressObj address for which the sponsorship is checked757 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});758 * @returns number of blocks or null if sponsorship hasn't been set759 */760 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {761 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();762 }763764 /**765 * Get the number of created collections.766 *767 * @returns number of created collections768 */769 async getTotalCount(): Promise<number> {770 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();771 }772773 /**774 * Get information about the collection with additional data,775 * including the number of tokens it contains, its administrators,776 * the normalized address of the collection's owner, and decoded name and description.777 *778 * @param collectionId ID of collection779 * @example await getData(2)780 * @returns collection information object781 */782 async getData(collectionId: number): Promise<{783 id: number;784 name: string;785 description: string;786 tokensCount: number;787 admins: CrossAccountId[];788 normalizedOwner: TSubstrateAccount;789 raw: any790 } | null> {791 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);792 const humanCollection = collection.toHuman(), collectionData = {793 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],794 raw: humanCollection,795 } as any, jsonCollection = collection.toJSON();796 if (humanCollection === null) return null;797 collectionData.raw.limits = jsonCollection.limits;798 collectionData.raw.permissions = jsonCollection.permissions;799 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);800 for (const key of ['name', 'description']) {801 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);802 }803804 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))805 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)806 : 0;807 collectionData.admins = await this.getAdmins(collectionId);808809 return collectionData;810 }811812 /**813 * Get the addresses of the collection's administrators, optionally normalized.814 *815 * @param collectionId ID of collection816 * @param normalize whether to normalize the addresses to the default ss58 format817 * @example await getAdmins(1)818 * @returns array of administrators819 */820 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {821 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();822823 return normalize824 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())825 : admins;826 }827828 /**829 * Get the addresses added to the collection allow-list, optionally normalized.830 * @param collectionId ID of collection831 * @param normalize whether to normalize the addresses to the default ss58 format832 * @example await getAllowList(1)833 * @returns array of allow-listed addresses834 */835 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {836 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();837 return normalize838 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())839 : allowListed;840 }841842 /**843 * Get the effective limits of the collection instead of null for default values844 *845 * @param collectionId ID of collection846 * @example await getEffectiveLimits(2)847 * @returns object of collection limits848 */849 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {850 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();851 }852853 /**854 * Burns the collection if the signer has sufficient permissions and collection is empty.855 *856 * @param signer keyring of signer857 * @param collectionId ID of collection858 * @example await helper.collection.burn(aliceKeyring, 3);859 * @returns ```true``` if extrinsic success, otherwise ```false```860 */861 async burn(signer: TSigner, collectionId: number): Promise<boolean> {862 const result = await this.helper.executeExtrinsic(863 signer,864 'api.tx.unique.destroyCollection', [collectionId],865 true,866 );867868 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');869 }870871 /**872 * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.873 *874 * @param signer keyring of signer875 * @param collectionId ID of collection876 * @param sponsorAddress Sponsor substrate address877 * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")878 * @returns ```true``` if extrinsic success, otherwise ```false```879 */880 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {881 const result = await this.helper.executeExtrinsic(882 signer,883 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],884 true,885 );886887 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorSet');888 }889890 /**891 * Confirms consent to sponsor the collection on behalf of the signer.892 *893 * @param signer keyring of signer894 * @param collectionId ID of collection895 * @example confirmSponsorship(aliceKeyring, 10)896 * @returns ```true``` if extrinsic success, otherwise ```false```897 */898 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {899 const result = await this.helper.executeExtrinsic(900 signer,901 'api.tx.unique.confirmSponsorship', [collectionId],902 true,903 );904905 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'SponsorshipConfirmed');906 }907908 /**909 * Removes the sponsor of a collection, regardless if it consented or not.910 *911 * @param signer keyring of signer912 * @param collectionId ID of collection913 * @example removeSponsor(aliceKeyring, 10)914 * @returns ```true``` if extrinsic success, otherwise ```false```915 */916 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {917 const result = await this.helper.executeExtrinsic(918 signer,919 'api.tx.unique.removeCollectionSponsor', [collectionId],920 true,921 );922923 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorRemoved');924 }925926 /**927 * Sets the limits of the collection. At least one limit must be specified for a correct call.928 *929 * @param signer keyring of signer930 * @param collectionId ID of collection931 * @param limits collection limits object932 * @example933 * await setLimits(934 * aliceKeyring,935 * 10,936 * {937 * sponsorTransferTimeout: 0,938 * ownerCanDestroy: false939 * }940 * )941 * @returns ```true``` if extrinsic success, otherwise ```false```942 */943 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {944 const result = await this.helper.executeExtrinsic(945 signer,946 'api.tx.unique.setCollectionLimits', [collectionId, limits],947 true,948 );949950 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionLimitSet');951 }952953 /**954 * Changes the owner of the collection to the new Substrate address.955 *956 * @param signer keyring of signer957 * @param collectionId ID of collection958 * @param ownerAddress substrate address of new owner959 * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")960 * @returns ```true``` if extrinsic success, otherwise ```false```961 */962 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {963 const result = await this.helper.executeExtrinsic(964 signer,965 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],966 true,967 );968969 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionOwnerChanged');970 }971972 /**973 * Adds a collection administrator.974 *975 * @param signer keyring of signer976 * @param collectionId ID of collection977 * @param adminAddressObj Administrator address (substrate or ethereum)978 * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})979 * @returns ```true``` if extrinsic success, otherwise ```false```980 */981 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {982 const result = await this.helper.executeExtrinsic(983 signer,984 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],985 true,986 );987988 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminAdded');989 }990991 /**992 * Removes a collection administrator.993 *994 * @param signer keyring of signer995 * @param collectionId ID of collection996 * @param adminAddressObj Administrator address (substrate or ethereum)997 * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})998 * @returns ```true``` if extrinsic success, otherwise ```false```999 */1000 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {1001 const result = await this.helper.executeExtrinsic(1002 signer,1003 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],1004 true,1005 );10061007 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminRemoved');1008 }10091010 /**1011 * Check if user is in allow list.1012 *1013 * @param collectionId ID of collection1014 * @param user Account to check1015 * @example await getAdmins(1)1016 * @returns is user in allow list1017 */1018 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {1019 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();1020 }10211022 /**1023 * Adds an address to allow list1024 * @param signer keyring of signer1025 * @param collectionId ID of collection1026 * @param addressObj address to add to the allow list1027 * @returns ```true``` if extrinsic success, otherwise ```false```1028 */1029 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1030 const result = await this.helper.executeExtrinsic(1031 signer,1032 'api.tx.unique.addToAllowList', [collectionId, addressObj],1033 true,1034 );10351036 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressAdded');1037 }10381039 /**1040 * Removes an address from allow list1041 *1042 * @param signer keyring of signer1043 * @param collectionId ID of collection1044 * @param addressObj address to remove from the allow list1045 * @returns ```true``` if extrinsic success, otherwise ```false```1046 */1047 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1048 const result = await this.helper.executeExtrinsic(1049 signer,1050 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],1051 true,1052 );10531054 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressRemoved');1055 }10561057 /**1058 * Sets onchain permissions for selected collection.1059 *1060 * @param signer keyring of signer1061 * @param collectionId ID of collection1062 * @param permissions collection permissions object1063 * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});1064 * @returns ```true``` if extrinsic success, otherwise ```false```1065 */1066 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {1067 const result = await this.helper.executeExtrinsic(1068 signer,1069 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],1070 true,1071 );10721073 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPermissionSet');1074 }10751076 /**1077 * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.1078 *1079 * @param signer keyring of signer1080 * @param collectionId ID of collection1081 * @param permissions nesting permissions object1082 * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});1083 * @returns ```true``` if extrinsic success, otherwise ```false```1084 */1085 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1086 return await this.setPermissions(signer, collectionId, {nesting: permissions});1087 }10881089 /**1090 * Disables nesting for selected collection.1091 *1092 * @param signer keyring of signer1093 * @param collectionId ID of collection1094 * @example disableNesting(aliceKeyring, 10);1095 * @returns ```true``` if extrinsic success, otherwise ```false```1096 */1097 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1098 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1099 }11001101 /**1102 * Sets onchain properties to the collection.1103 *1104 * @param signer keyring of signer1105 * @param collectionId ID of collection1106 * @param properties array of property objects1107 * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);1108 * @returns ```true``` if extrinsic success, otherwise ```false```1109 */1110 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1111 const result = await this.helper.executeExtrinsic(1112 signer,1113 'api.tx.unique.setCollectionProperties', [collectionId, properties],1114 true,1115 );11161117 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1118 }11191120 /**1121 * Get collection properties.1122 *1123 * @param collectionId ID of collection1124 * @param propertyKeys optionally filter the returned properties to only these keys1125 * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1126 * @returns array of key-value pairs1127 */1128 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1129 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1130 }11311132 async getPropertiesConsumedSpace(collectionId: number): Promise<number> {1133 const api = this.helper.getApi();1134 const props = (await api.query.common.collectionProperties(collectionId)).toJSON();11351136 return (props! as any).consumedSpace;1137 }11381139 async getCollectionOptions(collectionId: number) {1140 return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1141 }11421143 /**1144 * Deletes onchain properties from the collection.1145 *1146 * @param signer keyring of signer1147 * @param collectionId ID of collection1148 * @param propertyKeys array of property keys to delete1149 * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1150 * @returns ```true``` if extrinsic success, otherwise ```false```1151 */1152 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1153 const result = await this.helper.executeExtrinsic(1154 signer,1155 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1156 true,1157 );11581159 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1160 }11611162 /**1163 * Changes the owner of the token.1164 *1165 * @param signer keyring of signer1166 * @param collectionId ID of collection1167 * @param tokenId ID of token1168 * @param addressObj address of a new owner1169 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1170 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1171 * @returns true if the token success, otherwise false1172 */1173 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1174 const result = await this.helper.executeExtrinsic(1175 signer,1176 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1177 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1178 );11791180 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1181 }11821183 /**1184 *1185 * Change ownership of a token(s) on behalf of the owner.1186 *1187 * @param signer keyring of signer1188 * @param collectionId ID of collection1189 * @param tokenId ID of token1190 * @param fromAddressObj address on behalf of which the token will be sent1191 * @param toAddressObj new token owner1192 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1193 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1194 * @returns true if the token success, otherwise false1195 */1196 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1197 const result = await this.helper.executeExtrinsic(1198 signer,1199 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1200 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1201 );1202 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1203 }12041205 /**1206 *1207 * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1208 *1209 * @param signer keyring of signer1210 * @param collectionId ID of collection1211 * @param tokenId ID of token1212 * @param amount amount of tokens to be burned. For NFT must be set to 1n1213 * @example burnToken(aliceKeyring, 10, 5);1214 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1215 */1216 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1217 const burnResult = await this.helper.executeExtrinsic(1218 signer,1219 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1220 true, // `Unable to burn token for ${label}`,1221 );1222 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1223 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1224 return burnedTokens.success;1225 }12261227 /**1228 * Destroys a concrete instance of NFT on behalf of the owner1229 *1230 * @param signer keyring of signer1231 * @param collectionId ID of collection1232 * @param tokenId ID of token1233 * @param fromAddressObj address on behalf of which the token will be burnt1234 * @param amount amount of tokens to be burned. For NFT must be set to 1n1235 * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1236 * @returns ```true``` if extrinsic success, otherwise ```false```1237 */1238 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1239 const burnResult = await this.helper.executeExtrinsic(1240 signer,1241 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1242 true, // `Unable to burn token from for ${label}`,1243 );1244 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1245 return burnedTokens.success && burnedTokens.tokens.length > 0;1246 }12471248 /**1249 * Set, change, or remove approved address to transfer the ownership of the NFT.1250 *1251 * @param signer keyring of signer1252 * @param collectionId ID of collection1253 * @param tokenId ID of token1254 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1255 * @param amount amount of token to be approved. For NFT must be set to 1n1256 * @returns ```true``` if extrinsic success, otherwise ```false```1257 */1258 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1259 const approveResult = await this.helper.executeExtrinsic(1260 signer,1261 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1262 true, // `Unable to approve token for ${label}`,1263 );12641265 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1266 }12671268 /**1269 * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1270 *1271 * @param signer keyring of signer1272 * @param collectionId ID of collection1273 * @param tokenId ID of token1274 * @param fromAddressObj Signer's Ethereum address containing her tokens1275 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1276 * @param amount amount of token to be approved. For NFT must be set to 1n1277 * @returns ```true``` if extrinsic success, otherwise ```false```1278 */1279 async approveTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1280 const approveResult = await this.helper.executeExtrinsic(1281 signer,1282 'api.tx.unique.approveFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1283 true, // `Unable to approve token for ${label}`,1284 );12851286 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1287 }12881289 /**1290 * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1291 *1292 * @param signer keyring of signer1293 * @param collectionId ID of collection1294 * @param tokenId ID of token1295 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1296 * @param amount amount of token to be approved. For NFT must be set to 1n1297 * @returns ```true``` if extrinsic success, otherwise ```false```1298 */1299 async approveTokenFromEth(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1300 const ethMirror = CrossAccountId.fromKeyring(signer).toEthereum();1301 return await this.approveTokenFrom(signer, collectionId, tokenId, ethMirror, toAddressObj, amount);1302 }13031304 /**1305 * Get the amount of token pieces approved to transfer or burn. Normally 0.1306 *1307 * @param collectionId ID of collection1308 * @param tokenId ID of token1309 * @param toAccountObj address which is approved to use token pieces1310 * @param fromAccountObj address which may have allowed the use of its owned tokens1311 * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1312 * @returns number of approved to transfer pieces1313 */1314 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1315 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1316 }13171318 /**1319 * Get the last created token ID in a collection1320 *1321 * @param collectionId ID of collection1322 * @example getLastTokenId(10);1323 * @returns id of the last created token1324 */1325 async getLastTokenId(collectionId: number): Promise<number> {1326 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1327 }13281329 /**1330 * Check if token exists1331 *1332 * @param collectionId ID of collection1333 * @param tokenId ID of token1334 * @example doesTokenExist(10, 20);1335 * @returns true if the token exists, otherwise false1336 */1337 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1338 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1339 }1340}13411342class NFTnRFT extends CollectionGroup {1343 /**1344 * Get tokens owned by account1345 *1346 * @param collectionId ID of collection1347 * @param addressObj tokens owner1348 * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1349 * @returns array of token ids owned by account1350 */1351 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1352 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1353 }13541355 /**1356 * Get token data1357 *1358 * @param collectionId ID of collection1359 * @param tokenId ID of token1360 * @param propertyKeys optionally filter the token properties to only these keys1361 * @param blockHashAt optionally query the data at some block with this hash1362 * @example getToken(10, 5);1363 * @returns human readable token data1364 */1365 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1366 properties: IProperty[];1367 owner: CrossAccountId;1368 normalizedOwner: CrossAccountId;1369 }| null> {1370 let tokenData;1371 if(typeof blockHashAt === 'undefined') {1372 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1373 }1374 else {1375 if(propertyKeys.length == 0) {1376 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1377 if(!collection) return null;1378 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1379 }1380 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1381 }1382 tokenData = tokenData.toHuman();1383 if (tokenData === null || tokenData.owner === null) return null;1384 const owner = {} as any;1385 for (const key of Object.keys(tokenData.owner)) {1386 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'1387 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])1388 : tokenData.owner[key];1389 }1390 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1391 return tokenData;1392 }13931394 /**1395 * Get token's owner1396 * @param collectionId ID of collection1397 * @param tokenId ID of token1398 * @param blockHashAt optionally query the data at the block with this hash1399 * @example getTokenOwner(10, 5);1400 * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1401 */1402 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1403 let owner;1404 if (typeof blockHashAt === 'undefined') {1405 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1406 } else {1407 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1408 }1409 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1410 }14111412 /**1413 * Recursively find the address that owns the token1414 * @param collectionId ID of collection1415 * @param tokenId ID of token1416 * @param blockHashAt1417 * @example getTokenTopmostOwner(10, 5);1418 * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1419 */1420 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1421 let owner;1422 if (typeof blockHashAt === 'undefined') {1423 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1424 } else {1425 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1426 }14271428 if (owner === null) return null;14291430 return owner.toHuman();1431 }14321433 /**1434 * Nest one token into another1435 * @param signer keyring of signer1436 * @param tokenObj token to be nested1437 * @param rootTokenObj token to be parent1438 * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1439 * @returns ```true``` if extrinsic success, otherwise ```false```1440 */1441 async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1442 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1443 const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1444 if(!result) {1445 throw Error('Unable to nest token!');1446 }1447 return result;1448 }14491450 /**1451 * Remove token from nested state1452 * @param signer keyring of signer1453 * @param tokenObj token to unnest1454 * @param rootTokenObj parent of a token1455 * @param toAddressObj address of a new token owner1456 * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1457 * @returns ```true``` if extrinsic success, otherwise ```false```1458 */1459 async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1460 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1461 const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1462 if(!result) {1463 throw Error('Unable to unnest token!');1464 }1465 return result;1466 }14671468 /**1469 * Set permissions to change token properties1470 *1471 * @param signer keyring of signer1472 * @param collectionId ID of collection1473 * @param permissions permissions to change a property by the collection admin or token owner1474 * @example setTokenPropertyPermissions(1475 * aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1476 * )1477 * @returns true if extrinsic success otherwise false1478 */1479 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1480 const result = await this.helper.executeExtrinsic(1481 signer,1482 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1483 true,1484 );14851486 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1487 }14881489 /**1490 * Get token property permissions.1491 *1492 * @param collectionId ID of collection1493 * @param propertyKeys optionally filter the returned property permissions to only these keys1494 * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1495 * @returns array of key-permission pairs1496 */1497 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1498 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1499 }15001501 /**1502 * Set token properties1503 *1504 * @param signer keyring of signer1505 * @param collectionId ID of collection1506 * @param tokenId ID of token1507 * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1508 * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1509 * @returns ```true``` if extrinsic success, otherwise ```false```1510 */1511 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1512 const result = await this.helper.executeExtrinsic(1513 signer,1514 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1515 true,1516 );15171518 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1519 }15201521 /**1522 * Get properties, metadata assigned to a token.1523 *1524 * @param collectionId ID of collection1525 * @param tokenId ID of token1526 * @param propertyKeys optionally filter the returned properties to only these keys1527 * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1528 * @returns array of key-value pairs1529 */1530 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1531 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1532 }15331534 /**1535 * Delete the provided properties of a token1536 * @param signer keyring of signer1537 * @param collectionId ID of collection1538 * @param tokenId ID of token1539 * @param propertyKeys property keys to be deleted1540 * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1541 * @returns ```true``` if extrinsic success, otherwise ```false```1542 */1543 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1544 const result = await this.helper.executeExtrinsic(1545 signer,1546 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1547 true,1548 );15491550 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1551 }15521553 /**1554 * Mint new collection1555 *1556 * @param signer keyring of signer1557 * @param collectionOptions basic collection options and properties1558 * @param mode NFT or RFT type of a collection1559 * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1560 * @returns object of the created collection1561 */1562 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1563 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1564 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1565 for (const key of ['name', 'description', 'tokenPrefix']) {1566 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);1567 }1568 const creationResult = await this.helper.executeExtrinsic(1569 signer,1570 'api.tx.unique.createCollectionEx', [collectionOptions],1571 true, // errorLabel,1572 );1573 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1574 }15751576 getCollectionObject(_collectionId: number): any {1577 return null;1578 }15791580 getTokenObject(_collectionId: number, _tokenId: number): any {1581 return null;1582 }15831584 /**1585 * Tells whether the given `owner` approves the `operator`.1586 * @param collectionId ID of collection1587 * @param owner owner address1588 * @param operator operator addrees1589 * @returns true if operator is enabled1590 */1591 async allowanceForAll(collectionId: number, owner: ICrossAccountId, operator: ICrossAccountId): Promise<boolean> {1592 return (await this.helper.callRpc('api.rpc.unique.allowanceForAll', [collectionId, owner, operator])).toJSON();1593 }15941595 /** Sets or unsets the approval of a given operator.1596 * The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1597 * @param operator Operator1598 * @param approved Should operator status be granted or revoked?1599 * @returns ```true``` if extrinsic success, otherwise ```false```1600 */1601 async setAllowanceForAll(signer: TSigner, collectionId: number, operator: ICrossAccountId, approved: boolean): Promise<boolean> {1602 const result = await this.helper.executeExtrinsic(1603 signer,1604 'api.tx.unique.setAllowanceForAll', [collectionId, operator, approved],1605 true,1606 );1607 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'ApprovedForAll');1608 }1609}161016111612class NFTGroup extends NFTnRFT {1613 /**1614 * Get collection object1615 * @param collectionId ID of collection1616 * @example getCollectionObject(2);1617 * @returns instance of UniqueNFTCollection1618 */1619 getCollectionObject(collectionId: number): UniqueNFTCollection {1620 return new UniqueNFTCollection(collectionId, this.helper);1621 }16221623 /**1624 * Get token object1625 * @param collectionId ID of collection1626 * @param tokenId ID of token1627 * @example getTokenObject(10, 5);1628 * @returns instance of UniqueNFTToken1629 */1630 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1631 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1632 }16331634 /**1635 * Is token approved to transfer1636 * @param collectionId ID of collection1637 * @param tokenId ID of token1638 * @param toAccountObj address to be approved1639 * @returns ```true``` if extrinsic success, otherwise ```false```1640 */1641 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1642 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1643 }16441645 /**1646 * Changes the owner of the token.1647 *1648 * @param signer keyring of signer1649 * @param collectionId ID of collection1650 * @param tokenId ID of token1651 * @param addressObj address of a new owner1652 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1653 * @returns ```true``` if extrinsic success, otherwise ```false```1654 */1655 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1656 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1657 }16581659 /**1660 *1661 * Change ownership of a NFT on behalf of the owner.1662 *1663 * @param signer keyring of signer1664 * @param collectionId ID of collection1665 * @param tokenId ID of token1666 * @param fromAddressObj address on behalf of which the token will be sent1667 * @param toAddressObj new token owner1668 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1669 * @returns ```true``` if extrinsic success, otherwise ```false```1670 */1671 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1672 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1673 }16741675 /**1676 * Get tokens nested in the provided token1677 * @param collectionId ID of collection1678 * @param tokenId ID of token1679 * @param blockHashAt optionally query the data at the block with this hash1680 * @example getTokenChildren(10, 5);1681 * @returns tokens whose depth of nesting is <= 51682 */1683 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1684 let children;1685 if(typeof blockHashAt === 'undefined') {1686 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1687 } else {1688 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1689 }16901691 return children.toJSON().map((x: any) => {1692 return {collectionId: x.collection, tokenId: x.token};1693 });1694 }16951696 /**1697 * Mint new collection1698 * @param signer keyring of signer1699 * @param collectionOptions Collection options1700 * @example1701 * mintCollection(aliceKeyring, {1702 * name: 'New',1703 * description: 'New collection',1704 * tokenPrefix: 'NEW',1705 * })1706 * @returns object of the created collection1707 */1708 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1709 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1710 }17111712 /**1713 * Mint new token1714 * @param signer keyring of signer1715 * @param data token data1716 * @returns created token object1717 */1718 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1719 const creationResult = await this.helper.executeExtrinsic(1720 signer,1721 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1722 nft: {1723 properties: data.properties,1724 },1725 }],1726 true,1727 );1728 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1729 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1730 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1731 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1732 }17331734 /**1735 * Mint multiple NFT tokens1736 * @param signer keyring of signer1737 * @param collectionId ID of collection1738 * @param tokens array of tokens with owner and properties1739 * @example1740 * mintMultipleTokens(aliceKeyring, 10, [{1741 * owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1742 * properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1743 * },{1744 * owner: {Ethereum: "0x9F0583DbB855d..."},1745 * properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1746 * }]);1747 * @returns ```true``` if extrinsic success, otherwise ```false```1748 */1749 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1750 const creationResult = await this.helper.executeExtrinsic(1751 signer,1752 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1753 true,1754 );1755 const collection = this.getCollectionObject(collectionId);1756 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1757 }17581759 /**1760 * Mint multiple NFT tokens with one owner1761 * @param signer keyring of signer1762 * @param collectionId ID of collection1763 * @param owner tokens owner1764 * @param tokens array of tokens with owner and properties1765 * @example1766 * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1767 * properties: [{1768 * key: "gender",1769 * value: "female",1770 * },{1771 * key: "age",1772 * value: "33",1773 * }],1774 * }]);1775 * @returns array of newly created tokens1776 */1777 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1778 const rawTokens = [];1779 for (const token of tokens) {1780 const raw = {NFT: {properties: token.properties}};1781 rawTokens.push(raw);1782 }1783 const creationResult = await this.helper.executeExtrinsic(1784 signer,1785 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1786 true,1787 );1788 const collection = this.getCollectionObject(collectionId);1789 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1790 }17911792 /**1793 * Set, change, or remove approved address to transfer the ownership of the NFT.1794 *1795 * @param signer keyring of signer1796 * @param collectionId ID of collection1797 * @param tokenId ID of token1798 * @param toAddressObj address to approve1799 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1800 * @returns ```true``` if extrinsic success, otherwise ```false```1801 */1802 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1803 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1804 }1805}180618071808class RFTGroup extends NFTnRFT {1809 /**1810 * Get collection object1811 * @param collectionId ID of collection1812 * @example getCollectionObject(2);1813 * @returns instance of UniqueRFTCollection1814 */1815 getCollectionObject(collectionId: number): UniqueRFTCollection {1816 return new UniqueRFTCollection(collectionId, this.helper);1817 }18181819 /**1820 * Get token object1821 * @param collectionId ID of collection1822 * @param tokenId ID of token1823 * @example getTokenObject(10, 5);1824 * @returns instance of UniqueNFTToken1825 */1826 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1827 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1828 }18291830 /**1831 * Get top 10 token owners with the largest number of pieces1832 * @param collectionId ID of collection1833 * @param tokenId ID of token1834 * @example getTokenTop10Owners(10, 5);1835 * @returns array of top 10 owners1836 */1837 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1838 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1839 }18401841 /**1842 * Get number of pieces owned by address1843 * @param collectionId ID of collection1844 * @param tokenId ID of token1845 * @param addressObj address token owner1846 * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1847 * @returns number of pieces ownerd by address1848 */1849 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1850 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1851 }18521853 /**1854 * Transfer pieces of token to another address1855 * @param signer keyring of signer1856 * @param collectionId ID of collection1857 * @param tokenId ID of token1858 * @param addressObj address of a new owner1859 * @param amount number of pieces to be transfered1860 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1861 * @returns ```true``` if extrinsic success, otherwise ```false```1862 */1863 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1864 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1865 }18661867 /**1868 * Change ownership of some pieces of RFT on behalf of the owner.1869 * @param signer keyring of signer1870 * @param collectionId ID of collection1871 * @param tokenId ID of token1872 * @param fromAddressObj address on behalf of which the token will be sent1873 * @param toAddressObj new token owner1874 * @param amount number of pieces to be transfered1875 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1876 * @returns ```true``` if extrinsic success, otherwise ```false```1877 */1878 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1879 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1880 }18811882 /**1883 * Mint new collection1884 * @param signer keyring of signer1885 * @param collectionOptions Collection options1886 * @example1887 * mintCollection(aliceKeyring, {1888 * name: 'New',1889 * description: 'New collection',1890 * tokenPrefix: 'NEW',1891 * })1892 * @returns object of the created collection1893 */1894 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1895 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1896 }18971898 /**1899 * Mint new token1900 * @param signer keyring of signer1901 * @param data token data1902 * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1903 * @returns created token object1904 */1905 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1906 const creationResult = await this.helper.executeExtrinsic(1907 signer,1908 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1909 refungible: {1910 pieces: data.pieces,1911 properties: data.properties,1912 },1913 }],1914 true,1915 );1916 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1917 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1918 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1919 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1920 }19211922 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1923 throw Error('Not implemented');1924 const creationResult = await this.helper.executeExtrinsic(1925 signer,1926 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1927 true, // `Unable to mint RFT tokens for ${label}`,1928 );1929 const collection = this.getCollectionObject(collectionId);1930 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1931 }19321933 /**1934 * Mint multiple RFT tokens with one owner1935 * @param signer keyring of signer1936 * @param collectionId ID of collection1937 * @param owner tokens owner1938 * @param tokens array of tokens with properties and pieces1939 * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1940 * @returns array of newly created RFT tokens1941 */1942 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1943 const rawTokens = [];1944 for (const token of tokens) {1945 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1946 rawTokens.push(raw);1947 }1948 const creationResult = await this.helper.executeExtrinsic(1949 signer,1950 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1951 true,1952 );1953 const collection = this.getCollectionObject(collectionId);1954 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1955 }19561957 /**1958 * Destroys a concrete instance of RFT.1959 * @param signer keyring of signer1960 * @param collectionId ID of collection1961 * @param tokenId ID of token1962 * @param amount number of pieces to be burnt1963 * @example burnToken(aliceKeyring, 10, 5);1964 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1965 */1966 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1967 return await super.burnToken(signer, collectionId, tokenId, amount);1968 }19691970 /**1971 * Destroys a concrete instance of RFT on behalf of the owner.1972 * @param signer keyring of signer1973 * @param collectionId ID of collection1974 * @param tokenId ID of token1975 * @param fromAddressObj address on behalf of which the token will be burnt1976 * @param amount number of pieces to be burnt1977 * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1978 * @returns ```true``` if extrinsic success, otherwise ```false```1979 */1980 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1981 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1982 }19831984 /**1985 * Set, change, or remove approved address to transfer the ownership of the RFT.1986 *1987 * @param signer keyring of signer1988 * @param collectionId ID of collection1989 * @param tokenId ID of token1990 * @param toAddressObj address to approve1991 * @param amount number of pieces to be approved1992 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);1993 * @returns true if the token success, otherwise false1994 */1995 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1996 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1997 }19981999 /**2000 * Get total number of pieces2001 * @param collectionId ID of collection2002 * @param tokenId ID of token2003 * @example getTokenTotalPieces(10, 5);2004 * @returns number of pieces2005 */2006 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {2007 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();2008 }20092010 /**2011 * Change number of token pieces. Signer must be the owner of all token pieces.2012 * @param signer keyring of signer2013 * @param collectionId ID of collection2014 * @param tokenId ID of token2015 * @param amount new number of pieces2016 * @example repartitionToken(aliceKeyring, 10, 5, 12345n);2017 * @returns true if the repartion was success, otherwise false2018 */2019 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {2020 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);2021 const repartitionResult = await this.helper.executeExtrinsic(2022 signer,2023 'api.tx.unique.repartition', [collectionId, tokenId, amount],2024 true,2025 );2026 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');2027 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');2028 }2029}203020312032class FTGroup extends CollectionGroup {2033 /**2034 * Get collection object2035 * @param collectionId ID of collection2036 * @example getCollectionObject(2);2037 * @returns instance of UniqueFTCollection2038 */2039 getCollectionObject(collectionId: number): UniqueFTCollection {2040 return new UniqueFTCollection(collectionId, this.helper);2041 }20422043 /**2044 * Mint new fungible collection2045 * @param signer keyring of signer2046 * @param collectionOptions Collection options2047 * @param decimalPoints number of token decimals2048 * @example2049 * mintCollection(aliceKeyring, {2050 * name: 'New',2051 * description: 'New collection',2052 * tokenPrefix: 'NEW',2053 * }, 18)2054 * @returns newly created fungible collection2055 */2056 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {2057 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object2058 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');2059 collectionOptions.mode = {fungible: decimalPoints};2060 for (const key of ['name', 'description', 'tokenPrefix']) {2061 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);2062 }2063 const creationResult = await this.helper.executeExtrinsic(2064 signer,2065 'api.tx.unique.createCollectionEx', [collectionOptions],2066 true,2067 );2068 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));2069 }20702071 /**2072 * Mint tokens2073 * @param signer keyring of signer2074 * @param collectionId ID of collection2075 * @param owner address owner of new tokens2076 * @param amount amount of tokens to be meanted2077 * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);2078 * @returns ```true``` if extrinsic success, otherwise ```false```2079 */2080 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {2081 const creationResult = await this.helper.executeExtrinsic(2082 signer,2083 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {2084 fungible: {2085 value: amount,2086 },2087 }],2088 true, // `Unable to mint fungible tokens for ${label}`,2089 );2090 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2091 }20922093 /**2094 * Mint multiple Fungible tokens with one owner2095 * @param signer keyring of signer2096 * @param collectionId ID of collection2097 * @param owner tokens owner2098 * @param tokens array of tokens with properties and pieces2099 * @returns ```true``` if extrinsic success, otherwise ```false```2100 */2101 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {2102 const rawTokens = [];2103 for (const token of tokens) {2104 const raw = {Fungible: {Value: token.value}};2105 rawTokens.push(raw);2106 }2107 const creationResult = await this.helper.executeExtrinsic(2108 signer,2109 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],2110 true,2111 );2112 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2113 }21142115 /**2116 * Get the top 10 owners with the largest balance for the Fungible collection2117 * @param collectionId ID of collection2118 * @example getTop10Owners(10);2119 * @returns array of ```ICrossAccountId```2120 */2121 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {2122 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);2123 }21242125 /**2126 * Get account balance2127 * @param collectionId ID of collection2128 * @param addressObj address of owner2129 * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})2130 * @returns amount of fungible tokens owned by address2131 */2132 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {2133 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();2134 }21352136 /**2137 * Transfer tokens to address2138 * @param signer keyring of signer2139 * @param collectionId ID of collection2140 * @param toAddressObj address recipient2141 * @param amount amount of tokens to be sent2142 * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2143 * @returns ```true``` if extrinsic success, otherwise ```false```2144 */2145 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2146 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);2147 }21482149 /**2150 * Transfer some tokens on behalf of the owner.2151 * @param signer keyring of signer2152 * @param collectionId ID of collection2153 * @param fromAddressObj address on behalf of which tokens will be sent2154 * @param toAddressObj address where token to be sent2155 * @param amount number of tokens to be sent2156 * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);2157 * @returns ```true``` if extrinsic success, otherwise ```false```2158 */2159 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2160 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2161 }21622163 /**2164 * Destroy some amount of tokens2165 * @param signer keyring of signer2166 * @param collectionId ID of collection2167 * @param amount amount of tokens to be destroyed2168 * @example burnTokens(aliceKeyring, 10, 1000n);2169 * @returns ```true``` if extrinsic success, otherwise ```false```2170 */2171 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {2172 return await super.burnToken(signer, collectionId, 0, amount);2173 }21742175 /**2176 * Burn some tokens on behalf of the owner.2177 * @param signer keyring of signer2178 * @param collectionId ID of collection2179 * @param fromAddressObj address on behalf of which tokens will be burnt2180 * @param amount amount of tokens to be burnt2181 * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2182 * @returns ```true``` if extrinsic success, otherwise ```false```2183 */2184 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {2185 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2186 }21872188 /**2189 * Get total collection supply2190 * @param collectionId2191 * @returns2192 */2193 async getTotalPieces(collectionId: number): Promise<bigint> {2194 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2195 }21962197 /**2198 * Set, change, or remove approved address to transfer tokens.2199 *2200 * @param signer keyring of signer2201 * @param collectionId ID of collection2202 * @param toAddressObj address to be approved2203 * @param amount amount of tokens to be approved2204 * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2205 * @returns ```true``` if extrinsic success, otherwise ```false```2206 */2207 approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2208 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2209 }22102211 /**2212 * Get amount of fungible tokens approved to transfer2213 * @param collectionId ID of collection2214 * @param fromAddressObj owner of tokens2215 * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2216 * @returns number of tokens approved for the transfer2217 */2218 getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2219 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2220 }2221}222222232224class ChainGroup extends HelperGroup<ChainHelperBase> {2225 /**2226 * Get system properties of a chain2227 * @example getChainProperties();2228 * @returns ss58Format, token decimals, and token symbol2229 */2230 getChainProperties(): IChainProperties {2231 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2232 return {2233 ss58Format: properties.ss58Format.toJSON(),2234 tokenDecimals: properties.tokenDecimals.toJSON(),2235 tokenSymbol: properties.tokenSymbol.toJSON(),2236 };2237 }22382239 /**2240 * Get chain header2241 * @example getLatestBlockNumber();2242 * @returns the number of the last block2243 */2244 async getLatestBlockNumber(): Promise<number> {2245 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2246 }22472248 /**2249 * Get block hash by block number2250 * @param blockNumber number of block2251 * @example getBlockHashByNumber(12345);2252 * @returns hash of a block2253 */2254 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2255 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2256 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2257 return blockHash;2258 }22592260 // TODO add docs2261 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2262 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2263 if (!blockHash) return null;2264 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2265 }22662267 /**2268 * Get latest relay block2269 * @returns {number} relay block2270 */2271 async getRelayBlockNumber(): Promise<bigint> {2272 const blockNumber = (await this.helper.callRpc('api.query.parachainSystem.validationData')).toJSON().relayParentNumber;2273 return BigInt(blockNumber);2274 }22752276 /**2277 * Get account nonce2278 * @param address substrate address2279 * @example getNonce("5GrwvaEF5zXb26Fz...");2280 * @returns number, account's nonce2281 */2282 async getNonce(address: TSubstrateAccount): Promise<number> {2283 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2284 }2285}22862287class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2288 /**2289 * Get substrate address balance2290 * @param address substrate address2291 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2292 * @returns amount of tokens on address2293 */2294 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2295 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2296 }22972298 /**2299 * Transfer tokens to substrate address2300 * @param signer keyring of signer2301 * @param address substrate address of a recipient2302 * @param amount amount of tokens to be transfered2303 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2304 * @returns ```true``` if extrinsic success, otherwise ```false```2305 */2306 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2307 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}`*/);23082309 let transfer = {from: null, to: null, amount: 0n} as any;2310 result.result.events.forEach(({event: {data, method, section}}) => {2311 if ((section === 'balances') && (method === 'Transfer')) {2312 transfer = {2313 from: this.helper.address.normalizeSubstrate(data[0]),2314 to: this.helper.address.normalizeSubstrate(data[1]),2315 amount: BigInt(data[2]),2316 };2317 }2318 });2319 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from2320 && this.helper.address.normalizeSubstrate(address) === transfer.to2321 && BigInt(amount) === transfer.amount;2322 return isSuccess;2323 }23242325 /**2326 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2327 * @param address substrate address2328 * @returns2329 */2330 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2331 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2332 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2333 }23342335 async getLocked(address: TSubstrateAccount): Promise<[{id: string, amount: bigint, reason: string}]> {2336 const locks = (await this.helper.callRpc('api.query.balances.locks', [address])).toHuman();2337 return locks.map((lock: any) => {return {id: lock.id, amount: BigInt(lock.amount.replace(/,/g, '')), reasons: lock.reasons};});2338 }2339}23402341class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2342 /**2343 * Get ethereum address balance2344 * @param address ethereum address2345 * @example getEthereum("0x9F0583DbB855d...")2346 * @returns amount of tokens on address2347 */2348 async getEthereum(address: TEthereumAccount): Promise<bigint> {2349 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2350 }23512352 /**2353 * Transfer tokens to address2354 * @param signer keyring of signer2355 * @param address Ethereum address of a recipient2356 * @param amount amount of tokens to be transfered2357 * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2358 * @returns ```true``` if extrinsic success, otherwise ```false```2359 */2360 async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2361 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);23622363 let transfer = {from: null, to: null, amount: 0n} as any;2364 result.result.events.forEach(({event: {data, method, section}}) => {2365 if ((section === 'balances') && (method === 'Transfer')) {2366 transfer = {2367 from: data[0].toString(),2368 to: data[1].toString(),2369 amount: BigInt(data[2]),2370 };2371 }2372 });2373 const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from2374 && address === transfer.to2375 && BigInt(amount) === transfer.amount;2376 return isSuccess;2377 }2378}23792380class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2381 subBalanceGroup: SubstrateBalanceGroup<T>;2382 ethBalanceGroup: EthereumBalanceGroup<T>;23832384 constructor(helper: T) {2385 super(helper);2386 this.subBalanceGroup = new SubstrateBalanceGroup(helper);2387 this.ethBalanceGroup = new EthereumBalanceGroup(helper);2388 }23892390 getCollectionCreationPrice(): bigint {2391 return 2n * this.getOneTokenNominal();2392 }2393 /**2394 * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2395 * @example getOneTokenNominal()2396 * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2397 */2398 getOneTokenNominal(): bigint {2399 const chainProperties = this.helper.chain.getChainProperties();2400 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2401 }24022403 /**2404 * Get substrate address balance2405 * @param address substrate address2406 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2407 * @returns amount of tokens on address2408 */2409 getSubstrate(address: TSubstrateAccount): Promise<bigint> {2410 return this.subBalanceGroup.getSubstrate(address);2411 }24122413 /**2414 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2415 * @param address substrate address2416 * @returns2417 */2418 getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2419 return this.subBalanceGroup.getSubstrateFull(address);2420 }24212422 /**2423 * Get locked balances2424 * @param address substrate address2425 * @returns locked balances with reason via api.query.balances.locks2426 */2427 getLocked(address: TSubstrateAccount) {2428 return this.subBalanceGroup.getLocked(address);2429 }24302431 /**2432 * Get ethereum address balance2433 * @param address ethereum address2434 * @example getEthereum("0x9F0583DbB855d...")2435 * @returns amount of tokens on address2436 */2437 getEthereum(address: TEthereumAccount): Promise<bigint> {2438 return this.ethBalanceGroup.getEthereum(address);2439 }24402441 /**2442 * Transfer tokens to substrate address2443 * @param signer keyring of signer2444 * @param address substrate address of a recipient2445 * @param amount amount of tokens to be transfered2446 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2447 * @returns ```true``` if extrinsic success, otherwise ```false```2448 */2449 transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2450 return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2451 }24522453 async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2454 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);24552456 let transfer = {from: null, to: null, amount: 0n} as any;2457 result.result.events.forEach(({event: {data, method, section}}) => {2458 if ((section === 'balances') && (method === 'Transfer')) {2459 transfer = {2460 from: this.helper.address.normalizeSubstrate(data[0]),2461 to: this.helper.address.normalizeSubstrate(data[1]),2462 amount: BigInt(data[2]),2463 };2464 }2465 });2466 let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2467 isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2468 isSuccess = isSuccess && BigInt(amount) === transfer.amount;2469 return isSuccess;2470 }24712472 /**2473 * Transfer tokens with the unlock period2474 * @param signer signers Keyring2475 * @param address Substrate address of recipient2476 * @param schedule Schedule params2477 * @example vestedTransfer(signer, recepient.address, 20000, 100, 10, 50 * nominal); // total amount of vested tokens will be 100 * 50 = 50002478 */2479 async vestedTransfer(signer: TSigner, address: TSubstrateAccount, schedule: {start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}): Promise<void> {2480 const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.vestedTransfer', [address, schedule]);2481 const event = result.result.events2482 .find(e => e.event.section === 'vesting' &&2483 e.event.method === 'VestingScheduleAdded' &&2484 e.event.data[0].toHuman() === signer.address);2485 if (!event) throw Error('Cannot find transfer in events');2486 }24872488 /**2489 * Get schedule for recepient of vested transfer2490 * @param address Substrate address of recipient2491 * @returns2492 */2493 async getVestingSchedules(address: TSubstrateAccount): Promise<{start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}[]> {2494 const schedule = (await this.helper.callRpc('api.query.vesting.vestingSchedules', [address])).toJSON();2495 return schedule.map((schedule: any) => {2496 return {2497 start: BigInt(schedule.start),2498 period: BigInt(schedule.period),2499 periodCount: BigInt(schedule.periodCount),2500 perPeriod: BigInt(schedule.perPeriod),2501 };2502 });2503 }25042505 /**2506 * Claim vested tokens2507 * @param signer signers Keyring2508 */2509 async claim(signer: TSigner) {2510 const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.claim', []);2511 const event = result.result.events2512 .find(e => e.event.section === 'vesting' &&2513 e.event.method === 'Claimed' &&2514 e.event.data[0].toHuman() === signer.address);2515 if (!event) throw Error('Cannot find claim in events');2516 }2517}25182519class AddressGroup extends HelperGroup<ChainHelperBase> {2520 /**2521 * Normalizes the address to the specified ss58 format, by default ```42```.2522 * @param address substrate address2523 * @param ss58Format format for address conversion, by default ```42```2524 * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2525 * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2526 */2527 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2528 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2529 }25302531 /**2532 * Get address in the connected chain format2533 * @param address substrate address2534 * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2535 * @returns address in chain format2536 */2537 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2538 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2539 }25402541 /**2542 * Get substrate mirror of an ethereum address2543 * @param ethAddress ethereum address2544 * @param toChainFormat false for normalized account2545 * @example ethToSubstrate('0x9F0583DbB855d...')2546 * @returns substrate mirror of a provided ethereum address2547 */2548 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2549 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2550 }25512552 /**2553 * Get ethereum mirror of a substrate address2554 * @param subAddress substrate account2555 * @example substrateToEth("5DnSF6RRjwteE3BrC...")2556 * @returns ethereum mirror of a provided substrate address2557 */2558 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2559 return CrossAccountId.translateSubToEth(subAddress);2560 }25612562 /**2563 * Encode key to substrate address2564 * @param key key for encoding address2565 * @param ss58Format prefix for encoding to the address of the corresponding network2566 * @returns encoded substrate address2567 */2568 encodeSubstrateAddress (key: Uint8Array | string | bigint, ss58Format = 42): string {2569 const u8a :Uint8Array = typeof key === 'string'2570 ? hexToU8a(key)2571 : typeof key === 'bigint'2572 ? hexToU8a(key.toString(16))2573 : key;25742575 if (ss58Format < 0 || ss58Format > 16383 || [46, 47].includes(ss58Format)) {2576 throw new Error(`ss58Format is not valid, received ${typeofss58Format} "${ss58Format}"`);2577 }25782579 const allowedDecodedLengths = [1, 2, 4, 8, 32, 33];2580 if (!allowedDecodedLengths.includes(u8a.length)) {2581 throw new Error(`key length is not valid, received ${u8a.length}, valid values are ${allowedDecodedLengths.join(', ')}`);2582 }25832584 const u8aPrefix = ss58Format < 642585 ? new Uint8Array([ss58Format])2586 : new Uint8Array([2587 ((ss58Format & 0xfc) >> 2) | 0x40,2588 (ss58Format >> 8) | ((ss58Format & 0x03) << 6),2589 ]);25902591 const input = u8aConcat(u8aPrefix, u8a);25922593 return base58Encode(u8aConcat(2594 input,2595 blake2AsU8a(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1),2596 ));2597 }25982599 /**2600 * Restore substrate address from bigint representation2601 * @param number decimal representation of substrate address2602 * @returns substrate address2603 */2604 restoreCrossAccountFromBigInt(number: bigint): TSubstrateAccount {2605 if (this.helper.api === null) {2606 throw 'Not connected';2607 }2608 const res = this.helper.api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();2609 if (res === undefined || res === null) {2610 throw 'Restore address error';2611 }2612 return res.toString();2613 }26142615 /**2616 * Convert etherium cross account id to substrate cross account id2617 * @param ethCrossAccount etherium cross account2618 * @returns substrate cross account id2619 */2620 convertCrossAccountFromEthCrossAccount(ethCrossAccount: IEthCrossAccountId): ICrossAccountId {2621 if (ethCrossAccount.sub === '0') {2622 return {Ethereum: ethCrossAccount.eth.toLocaleLowerCase()};2623 }26242625 const ss58 = this.restoreCrossAccountFromBigInt(BigInt(ethCrossAccount.sub));2626 return {Substrate: ss58};2627 }26282629 paraSiblingSovereignAccount(paraid: number) {2630 // We are getting a *sibling* parachain sovereign account,2631 // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c2632 const siblingPrefix = '0x7369626c';26332634 const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2635 const suffix = '000000000000000000000000000000000000000000000000';26362637 return siblingPrefix + encodedParaId + suffix;2638 }2639}26402641class StakingGroup extends HelperGroup<UniqueHelper> {2642 /**2643 * Stake tokens for App Promotion2644 * @param signer keyring of signer2645 * @param amountToStake amount of tokens to stake2646 * @param label extra label for log2647 * @returns2648 */2649 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2650 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2651 const _stakeResult = await this.helper.executeExtrinsic(2652 signer, 'api.tx.appPromotion.stake',2653 [amountToStake], true,2654 );2655 // TODO extract info from stakeResult2656 return true;2657 }26582659 /**2660 * Unstake all staked tokens2661 * @param signer keyring of signer2662 * @param amountToUnstake amount of tokens to unstake2663 * @param label extra label for log2664 * @returns block hash where unstake happened2665 */2666 async unstakeAll(signer: TSigner, label?: string): Promise<string> {2667 if(typeof label === 'undefined') label = `${signer.address}`;2668 const unstakeResult = await this.helper.executeExtrinsic(2669 signer, 'api.tx.appPromotion.unstakeAll',2670 [], true,2671 );2672 return unstakeResult.blockHash;2673 }26742675 /**2676 * Unstake the part of a staked tokens2677 * @param signer keyring of signer2678 * @param amount amount of tokens to unstake2679 * @param label extra label for log2680 * @returns block hash where unstake happened2681 */2682 async unstakePartial(signer: TSigner, amount: bigint, label?: string): Promise<string> {2683 if(typeof label === 'undefined') label = `${signer.address}`;2684 const unstakeResult = await this.helper.executeExtrinsic(2685 signer, 'api.tx.appPromotion.unstakePartial',2686 [amount], true,2687 );2688 return unstakeResult.blockHash;2689 }26902691 /**2692 * Get total number of active stakes2693 * @param address substrate address2694 * @returns {number}2695 */2696 async getStakesNumber(address: ICrossAccountId): Promise<number> {2697 if (address.Ethereum) throw Error('only substrate address');2698 return (await this.helper.callRpc('api.query.appPromotion.stakesPerAccount', [address.Substrate])).toNumber();2699 }27002701 /**2702 * Get total staked amount for address2703 * @param address substrate or ethereum address2704 * @returns total staked amount2705 */2706 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2707 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2708 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2709 }27102711 /**2712 * Get total staked per block2713 * @param address substrate or ethereum address2714 * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2715 */2716 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2717 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2718 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2719 return {2720 block: block.toBigInt(),2721 amount: amount.toBigInt(),2722 };2723 });2724 }27252726 /**2727 * Get total pending unstake amount for address2728 * @param address substrate or ethereum address2729 * @returns total pending unstake amount2730 */2731 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2732 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2733 }27342735 /**2736 * Get pending unstake amount per block for address2737 * @param address substrate or ethereum address2738 * @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 block2739 */2740 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2741 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2742 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2743 return {2744 block: block.toBigInt(),2745 amount: amount.toBigInt(),2746 };2747 });2748 return result;2749 }2750}27512752class SchedulerGroup extends HelperGroup<UniqueHelper> {2753 constructor(helper: UniqueHelper) {2754 super(helper);2755 }27562757 cancelScheduled(signer: TSigner, scheduledId: string) {2758 return this.helper.executeExtrinsic(2759 signer,2760 'api.tx.scheduler.cancelNamed',2761 [scheduledId],2762 true,2763 );2764 }27652766 changePriority(signer: TSigner, scheduledId: string, priority: number) {2767 return this.helper.executeExtrinsic(2768 signer,2769 'api.tx.scheduler.changeNamedPriority',2770 [scheduledId, priority],2771 true,2772 );2773 }27742775 scheduleAt<T extends UniqueHelper>(2776 executionBlockNumber: number,2777 options: ISchedulerOptions = {},2778 ) {2779 return this.schedule<T>('schedule', executionBlockNumber, options);2780 }27812782 scheduleAfter<T extends UniqueHelper>(2783 blocksBeforeExecution: number,2784 options: ISchedulerOptions = {},2785 ) {2786 return this.schedule<T>('scheduleAfter', blocksBeforeExecution, options);2787 }27882789 schedule<T extends UniqueHelper>(2790 scheduleFn: 'schedule' | 'scheduleAfter',2791 blocksNum: number,2792 options: ISchedulerOptions = {},2793 ) {2794 // eslint-disable-next-line @typescript-eslint/naming-convention2795 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2796 return this.helper.clone(ScheduledHelperType, {2797 scheduleFn,2798 blocksNum,2799 options,2800 }) as T;2801 }2802}28032804class CollatorSelectionGroup extends HelperGroup<UniqueHelper> {2805 //todo:collator documentation2806 addInvulnerable(signer: TSigner, address: string) {2807 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.addInvulnerable', [address]);2808 }28092810 removeInvulnerable(signer: TSigner, address: string) {2811 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.removeInvulnerable', [address]);2812 }28132814 async getInvulnerables(): Promise<string[]> {2815 return (await this.helper.callRpc('api.query.collatorSelection.invulnerables')).map((x: any) => x.toHuman());2816 }28172818 /** and also total max invulnerables */2819 maxCollators(): number {2820 return (this.helper.getApi().consts.configuration.defaultCollatorSelectionMaxCollators.toJSON() as number);2821 }28222823 async getDesiredCollators(): Promise<number> {2824 return (await this.helper.callRpc('api.query.configuration.collatorSelectionDesiredCollatorsOverride')).toNumber();2825 }28262827 setLicenseBond(signer: TSigner, amount: bigint) {2828 return this.helper.executeExtrinsic(signer, 'api.tx.configuration.setCollatorSelectionLicenseBond', [amount]);2829 }28302831 async getLicenseBond(): Promise<bigint> {2832 return (await this.helper.callRpc('api.query.configuration.collatorSelectionLicenseBondOverride')).toBigInt();2833 }28342835 obtainLicense(signer: TSigner) {2836 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.getLicense', []);2837 }28382839 releaseLicense(signer: TSigner) {2840 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.releaseLicense', []);2841 }28422843 forceReleaseLicense(signer: TSigner, released: string) {2844 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.forceReleaseLicense', [released]);2845 }28462847 async hasLicense(address: string): Promise<bigint> {2848 return (await this.helper.callRpc('api.query.collatorSelection.licenseDepositOf', [address])).toBigInt();2849 }28502851 onboard(signer: TSigner) {2852 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.onboard', []);2853 }28542855 offboard(signer: TSigner) {2856 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.offboard', []);2857 }28582859 async getCandidates(): Promise<string[]> {2860 return (await this.helper.callRpc('api.query.collatorSelection.candidates')).map((x: any) => x.toHuman());2861 }2862}28632864class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2865 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2866 await this.helper.executeExtrinsic(2867 signer,2868 'api.tx.foreignAssets.registerForeignAsset',2869 [ownerAddress, location, metadata],2870 true,2871 );2872 }28732874 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2875 await this.helper.executeExtrinsic(2876 signer,2877 'api.tx.foreignAssets.updateForeignAsset',2878 [foreignAssetId, location, metadata],2879 true,2880 );2881 }2882}28832884class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2885 palletName: string;28862887 constructor(helper: T, palletName: string) {2888 super(helper);28892890 this.palletName = palletName;2891 }28922893 async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: any) {2894 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, weightLimit], true);2895 }28962897 async teleportAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number) {2898 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.teleportAssets`, [destination, beneficiary, assets, feeAssetItem], true);2899 }29002901 async teleportNativeAsset(signer: TSigner, destinationParaId: number, targetAccount: Uint8Array, amount: bigint) {2902 const destination = {2903 V1: {2904 parents: 0,2905 interior: {2906 X1: {2907 Parachain: destinationParaId,2908 },2909 },2910 },2911 };29122913 const beneficiary = {2914 V1: {2915 parents: 0,2916 interior: {2917 X1: {2918 AccountId32: {2919 network: 'Any',2920 id: targetAccount,2921 },2922 },2923 },2924 },2925 };29262927 const assets = {2928 V1: [2929 {2930 id: {2931 Concrete: {2932 parents: 0,2933 interior: 'Here',2934 },2935 },2936 fun: {2937 Fungible: amount,2938 },2939 },2940 ],2941 };29422943 const feeAssetItem = 0;29442945 await this.teleportAssets(signer, destination, beneficiary, assets, feeAssetItem);2946 }2947}29482949class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2950 async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: any) {2951 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);2952 }29532954 async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: any) {2955 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);2956 }29572958 async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: any) {2959 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);2960 }2961}29622963class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2964 async accounts(address: string, currencyId: any) {2965 const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;2966 return BigInt(free);2967 }2968}29692970class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {2971 async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {2972 await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);2973 }29742975 async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {2976 await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);2977 }29782979 async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {2980 await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);2981 }29822983 async account(assetId: string | number, address: string) {2984 const accountAsset = (2985 await this.helper.callRpc('api.query.assets.account', [assetId, address])2986 ).toJSON()! as any;29872988 if (accountAsset !== null) {2989 return BigInt(accountAsset['balance']);2990 } else {2991 return null;2992 }2993 }2994}29952996class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {2997 async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {2998 await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);2999 }3000}30013002class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {3003 makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {3004 const apiPrefix = 'api.tx.assetManager.';30053006 const registerTx = this.helper.constructApiCall(3007 apiPrefix + 'registerForeignAsset',3008 [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],3009 );30103011 const setUnitsTx = this.helper.constructApiCall(3012 apiPrefix + 'setAssetUnitsPerSecond',3013 [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],3014 );30153016 const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);3017 const encodedProposal = batchCall?.method.toHex() || '';3018 return encodedProposal;3019 }30203021 async assetTypeId(location: any) {3022 return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);3023 }3024}30253026class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {3027 notePreimagePallet: string;30283029 constructor(helper: MoonbeamHelper, options: {[key: string]: any} = {}) {3030 super(helper);3031 this.notePreimagePallet = options.notePreimagePallet;3032 }30333034 async notePreimage(signer: TSigner, encodedProposal: string) {3035 await this.helper.executeExtrinsic(signer, `api.tx.${this.notePreimagePallet}.notePreimage`, [encodedProposal], true);3036 }30373038 externalProposeMajority(proposal: any) {3039 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposal]);3040 }30413042 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {3043 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);3044 }30453046 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {3047 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);3048 }3049}30503051class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {3052 collective: string;30533054 constructor(helper: MoonbeamHelper, collective: string) {3055 super(helper);30563057 this.collective = collective;3058 }30593060 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {3061 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);3062 }30633064 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {3065 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);3066 }30673068 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: any, lengthBound: number) {3069 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);3070 }30713072 async proposalCount() {3073 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));3074 }3075}30763077export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;3078export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;30793080export class UniqueHelper extends ChainHelperBase {3081 balance: BalanceGroup<UniqueHelper>;3082 collection: CollectionGroup;3083 nft: NFTGroup;3084 rft: RFTGroup;3085 ft: FTGroup;3086 staking: StakingGroup;3087 scheduler: SchedulerGroup;3088 collatorSelection: CollatorSelectionGroup;3089 foreignAssets: ForeignAssetsGroup;3090 xcm: XcmGroup<UniqueHelper>;3091 xTokens: XTokensGroup<UniqueHelper>;3092 tokens: TokensGroup<UniqueHelper>;30933094 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3095 super(logger, options.helperBase ?? UniqueHelper);30963097 this.balance = new BalanceGroup(this);3098 this.collection = new CollectionGroup(this);3099 this.nft = new NFTGroup(this);3100 this.rft = new RFTGroup(this);3101 this.ft = new FTGroup(this);3102 this.staking = new StakingGroup(this);3103 this.scheduler = new SchedulerGroup(this);3104 this.collatorSelection = new CollatorSelectionGroup(this);3105 this.foreignAssets = new ForeignAssetsGroup(this);3106 this.xcm = new XcmGroup(this, 'polkadotXcm');3107 this.xTokens = new XTokensGroup(this);3108 this.tokens = new TokensGroup(this);3109 }31103111 getSudo<T extends UniqueHelper>() {3112 // eslint-disable-next-line @typescript-eslint/naming-convention3113 const SudoHelperType = SudoHelper(this.helperBase);3114 return this.clone(SudoHelperType) as T;3115 }3116}31173118export class XcmChainHelper extends ChainHelperBase {3119 async connect(wsEndpoint: string, _listeners?: any): Promise<void> {3120 const wsProvider = new WsProvider(wsEndpoint);3121 this.api = new ApiPromise({3122 provider: wsProvider,3123 });3124 await this.api.isReadyOrError;3125 this.network = await UniqueHelper.detectNetwork(this.api);3126 }3127}31283129export class RelayHelper extends XcmChainHelper {3130 balance: SubstrateBalanceGroup<RelayHelper>;3131 xcm: XcmGroup<RelayHelper>;31323133 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3134 super(logger, options.helperBase ?? RelayHelper);31353136 this.balance = new SubstrateBalanceGroup(this);3137 this.xcm = new XcmGroup(this, 'xcmPallet');3138 }3139}31403141export class WestmintHelper extends XcmChainHelper {3142 balance: SubstrateBalanceGroup<WestmintHelper>;3143 xcm: XcmGroup<WestmintHelper>;3144 assets: AssetsGroup<WestmintHelper>;3145 xTokens: XTokensGroup<WestmintHelper>;31463147 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3148 super(logger, options.helperBase ?? WestmintHelper);31493150 this.balance = new SubstrateBalanceGroup(this);3151 this.xcm = new XcmGroup(this, 'polkadotXcm');3152 this.assets = new AssetsGroup(this);3153 this.xTokens = new XTokensGroup(this);3154 }3155}31563157export class MoonbeamHelper extends XcmChainHelper {3158 balance: EthereumBalanceGroup<MoonbeamHelper>;3159 assetManager: MoonbeamAssetManagerGroup;3160 assets: AssetsGroup<MoonbeamHelper>;3161 xTokens: XTokensGroup<MoonbeamHelper>;3162 democracy: MoonbeamDemocracyGroup;3163 collective: {3164 council: MoonbeamCollectiveGroup,3165 techCommittee: MoonbeamCollectiveGroup,3166 };31673168 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3169 super(logger, options.helperBase ?? MoonbeamHelper);31703171 this.balance = new EthereumBalanceGroup(this);3172 this.assetManager = new MoonbeamAssetManagerGroup(this);3173 this.assets = new AssetsGroup(this);3174 this.xTokens = new XTokensGroup(this);3175 this.democracy = new MoonbeamDemocracyGroup(this, options);3176 this.collective = {3177 council: new MoonbeamCollectiveGroup(this, 'councilCollective'),3178 techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),3179 };3180 }3181}31823183export class AcalaHelper extends XcmChainHelper {3184 balance: SubstrateBalanceGroup<AcalaHelper>;3185 assetRegistry: AcalaAssetRegistryGroup;3186 xTokens: XTokensGroup<AcalaHelper>;3187 tokens: TokensGroup<AcalaHelper>;31883189 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3190 super(logger, options.helperBase ?? AcalaHelper);31913192 this.balance = new SubstrateBalanceGroup(this);3193 this.assetRegistry = new AcalaAssetRegistryGroup(this);3194 this.xTokens = new XTokensGroup(this);3195 this.tokens = new TokensGroup(this);3196 }31973198 getSudo<T extends AcalaHelper>() {3199 // eslint-disable-next-line @typescript-eslint/naming-convention3200 const SudoHelperType = SudoHelper(this.helperBase);3201 return this.clone(SudoHelperType) as T;3202 }3203}32043205// eslint-disable-next-line @typescript-eslint/naming-convention3206function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {3207 return class extends Base {3208 scheduleFn: 'schedule' | 'scheduleAfter';3209 blocksNum: number;3210 options: ISchedulerOptions;32113212 constructor(...args: any[]) {3213 const logger = args[0] as ILogger;3214 const options = args[1] as {3215 scheduleFn: 'schedule' | 'scheduleAfter',3216 blocksNum: number,3217 options: ISchedulerOptions3218 };32193220 super(logger);32213222 this.scheduleFn = options.scheduleFn;3223 this.blocksNum = options.blocksNum;3224 this.options = options.options;3225 }32263227 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {3228 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);32293230 const mandatorySchedArgs = [3231 this.blocksNum,3232 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,3233 this.options.priority ?? null,3234 scheduledTx,3235 ];32363237 let schedArgs;3238 let scheduleFn;32393240 if (this.options.scheduledId) {3241 schedArgs = [this.options.scheduledId!, ...mandatorySchedArgs];32423243 if (this.scheduleFn == 'schedule') {3244 scheduleFn = 'scheduleNamed';3245 } else if (this.scheduleFn == 'scheduleAfter') {3246 scheduleFn = 'scheduleNamedAfter';3247 }3248 } else {3249 schedArgs = mandatorySchedArgs;3250 scheduleFn = this.scheduleFn;3251 }32523253 const extrinsic = 'api.tx.scheduler.' + scheduleFn;32543255 return super.executeExtrinsic(3256 sender,3257 extrinsic,3258 schedArgs,3259 expectSuccess,3260 );3261 }3262 };3263}32643265// eslint-disable-next-line @typescript-eslint/naming-convention3266function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {3267 return class extends Base {3268 constructor(...args: any[]) {3269 super(...args);3270 }32713272 async executeExtrinsic(3273 sender: IKeyringPair,3274 extrinsic: string,3275 params: any[],3276 expectSuccess?: boolean,3277 options: Partial<SignerOptions>|null = null,3278 ): Promise<ITransactionResult> {3279 const call = this.constructApiCall(extrinsic, params);3280 const result = await super.executeExtrinsic(3281 sender,3282 'api.tx.sudo.sudo',3283 [call],3284 expectSuccess,3285 options,3286 );32873288 if (result.status === 'Fail') return result;32893290 const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;3291 if (data.isErr) {3292 if (data.asErr.isModule) {3293 const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;3294 const metaError = super.getApi()?.registry.findMetaError(error);3295 throw new Error(`${metaError.section}.${metaError.name}`);3296 } else {3297 throw new Error(data.asErr.toHuman());3298 }3299 }3300 return result;3301 }3302 };3303}33043305export class UniqueBaseCollection {3306 helper: UniqueHelper;3307 collectionId: number;33083309 constructor(collectionId: number, uniqueHelper: UniqueHelper) {3310 this.collectionId = collectionId;3311 this.helper = uniqueHelper;3312 }33133314 async getData() {3315 return await this.helper.collection.getData(this.collectionId);3316 }33173318 async getLastTokenId() {3319 return await this.helper.collection.getLastTokenId(this.collectionId);3320 }33213322 async doesTokenExist(tokenId: number) {3323 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);3324 }33253326 async getAdmins() {3327 return await this.helper.collection.getAdmins(this.collectionId);3328 }33293330 async getAllowList() {3331 return await this.helper.collection.getAllowList(this.collectionId);3332 }33333334 async getEffectiveLimits() {3335 return await this.helper.collection.getEffectiveLimits(this.collectionId);3336 }33373338 async getProperties(propertyKeys?: string[] | null) {3339 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);3340 }33413342 async getPropertiesConsumedSpace() {3343 return await this.helper.collection.getPropertiesConsumedSpace(this.collectionId);3344 }33453346 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {3347 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);3348 }33493350 async getOptions() {3351 return await this.helper.collection.getCollectionOptions(this.collectionId);3352 }33533354 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {3355 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);3356 }33573358 async confirmSponsorship(signer: TSigner) {3359 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);3360 }33613362 async removeSponsor(signer: TSigner) {3363 return await this.helper.collection.removeSponsor(signer, this.collectionId);3364 }33653366 async setLimits(signer: TSigner, limits: ICollectionLimits) {3367 return await this.helper.collection.setLimits(signer, this.collectionId, limits);3368 }33693370 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {3371 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);3372 }33733374 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3375 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);3376 }33773378 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {3379 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);3380 }33813382 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {3383 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);3384 }33853386 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3387 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);3388 }33893390 async setProperties(signer: TSigner, properties: IProperty[]) {3391 return await this.helper.collection.setProperties(signer, this.collectionId, properties);3392 }33933394 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3395 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);3396 }33973398 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {3399 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);3400 }34013402 async enableNesting(signer: TSigner, permissions: INestingPermissions) {3403 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);3404 }34053406 async disableNesting(signer: TSigner) {3407 return await this.helper.collection.disableNesting(signer, this.collectionId);3408 }34093410 async burn(signer: TSigner) {3411 return await this.helper.collection.burn(signer, this.collectionId);3412 }34133414 scheduleAt<T extends UniqueHelper>(3415 executionBlockNumber: number,3416 options: ISchedulerOptions = {},3417 ) {3418 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3419 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3420 }34213422 scheduleAfter<T extends UniqueHelper>(3423 blocksBeforeExecution: number,3424 options: ISchedulerOptions = {},3425 ) {3426 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3427 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3428 }34293430 getSudo<T extends UniqueHelper>() {3431 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());3432 }3433}343434353436export class UniqueNFTCollection extends UniqueBaseCollection {3437 getTokenObject(tokenId: number) {3438 return new UniqueNFToken(tokenId, this);3439 }34403441 async getTokensByAddress(addressObj: ICrossAccountId) {3442 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);3443 }34443445 async getToken(tokenId: number, blockHashAt?: string) {3446 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);3447 }34483449 async getTokenOwner(tokenId: number, blockHashAt?: string) {3450 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3451 }34523453 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3454 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3455 }34563457 async getTokenChildren(tokenId: number, blockHashAt?: string) {3458 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);3459 }34603461 async getPropertyPermissions(propertyKeys: string[] | null = null) {3462 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);3463 }34643465 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3466 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3467 }34683469 async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3470 const api = this.helper.getApi();3471 const props = (await api.query.nonfungible.tokenProperties(this.collectionId, tokenId)).toJSON();34723473 return (props! as any).consumedSpace;3474 }34753476 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {3477 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);3478 }34793480 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3481 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);3482 }34833484 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {3485 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);3486 }34873488 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {3489 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);3490 }34913492 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3493 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});3494 }34953496 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {3497 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);3498 }34993500 async burnToken(signer: TSigner, tokenId: number) {3501 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);3502 }35033504 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {3505 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);3506 }35073508 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3509 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);3510 }35113512 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3513 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3514 }35153516 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3517 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3518 }35193520 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3521 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3522 }35233524 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3525 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3526 }35273528 scheduleAt<T extends UniqueHelper>(3529 executionBlockNumber: number,3530 options: ISchedulerOptions = {},3531 ) {3532 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3533 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3534 }35353536 scheduleAfter<T extends UniqueHelper>(3537 blocksBeforeExecution: number,3538 options: ISchedulerOptions = {},3539 ) {3540 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3541 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3542 }35433544 getSudo<T extends UniqueHelper>() {3545 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());3546 }3547}354835493550export class UniqueRFTCollection extends UniqueBaseCollection {3551 getTokenObject(tokenId: number) {3552 return new UniqueRFToken(tokenId, this);3553 }35543555 async getToken(tokenId: number, blockHashAt?: string) {3556 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);3557 }35583559 async getTokenOwner(tokenId: number, blockHashAt?: string) {3560 return await this.helper.rft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3561 }35623563 async getTokensByAddress(addressObj: ICrossAccountId) {3564 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);3565 }35663567 async getTop10TokenOwners(tokenId: number) {3568 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);3569 }35703571 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3572 return await this.helper.rft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3573 }35743575 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {3576 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3577 }35783579 async getTokenTotalPieces(tokenId: number) {3580 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3581 }35823583 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3584 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3585 }35863587 async getPropertyPermissions(propertyKeys: string[] | null = null) {3588 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3589 }35903591 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3592 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3593 }35943595 async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3596 const api = this.helper.getApi();3597 const props = (await api.query.refungible.tokenProperties(this.collectionId, tokenId)).toJSON();35983599 return (props! as any).consumedSpace;3600 }36013602 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3603 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3604 }36053606 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3607 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3608 }36093610 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3611 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3612 }36133614 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3615 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3616 }36173618 async mintToken(signer: TSigner, pieces = 1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3619 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3620 }36213622 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3623 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3624 }36253626 async burnToken(signer: TSigner, tokenId: number, amount=1n) {3627 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3628 }36293630 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {3631 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3632 }36333634 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3635 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3636 }36373638 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3639 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3640 }36413642 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3643 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3644 }36453646 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3647 return await this.helper.rft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3648 }36493650 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3651 return await this.helper.rft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3652 }36533654 scheduleAt<T extends UniqueHelper>(3655 executionBlockNumber: number,3656 options: ISchedulerOptions = {},3657 ) {3658 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3659 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3660 }36613662 scheduleAfter<T extends UniqueHelper>(3663 blocksBeforeExecution: number,3664 options: ISchedulerOptions = {},3665 ) {3666 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3667 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3668 }36693670 getSudo<T extends UniqueHelper>() {3671 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3672 }3673}367436753676export class UniqueFTCollection extends UniqueBaseCollection {3677 async getBalance(addressObj: ICrossAccountId) {3678 return await this.helper.ft.getBalance(this.collectionId, addressObj);3679 }36803681 async getTotalPieces() {3682 return await this.helper.ft.getTotalPieces(this.collectionId);3683 }36843685 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3686 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3687 }36883689 async getTop10Owners() {3690 return await this.helper.ft.getTop10Owners(this.collectionId);3691 }36923693 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3694 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3695 }36963697 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3698 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3699 }37003701 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3702 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3703 }37043705 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3706 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3707 }37083709 async burnTokens(signer: TSigner, amount=1n) {3710 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3711 }37123713 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3714 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3715 }37163717 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3718 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3719 }37203721 scheduleAt<T extends UniqueHelper>(3722 executionBlockNumber: number,3723 options: ISchedulerOptions = {},3724 ) {3725 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3726 return new UniqueFTCollection(this.collectionId, scheduledHelper);3727 }37283729 scheduleAfter<T extends UniqueHelper>(3730 blocksBeforeExecution: number,3731 options: ISchedulerOptions = {},3732 ) {3733 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3734 return new UniqueFTCollection(this.collectionId, scheduledHelper);3735 }37363737 getSudo<T extends UniqueHelper>() {3738 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3739 }3740}374137423743export class UniqueBaseToken {3744 collection: UniqueNFTCollection | UniqueRFTCollection;3745 collectionId: number;3746 tokenId: number;37473748 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3749 this.collection = collection;3750 this.collectionId = collection.collectionId;3751 this.tokenId = tokenId;3752 }37533754 async getNextSponsored(addressObj: ICrossAccountId) {3755 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3756 }37573758 async getProperties(propertyKeys?: string[] | null) {3759 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3760 }37613762 async getTokenPropertiesConsumedSpace() {3763 return await this.collection.getTokenPropertiesConsumedSpace(this.tokenId);3764 }37653766 async setProperties(signer: TSigner, properties: IProperty[]) {3767 return await this.collection.setTokenProperties(signer, this.tokenId, properties);3768 }37693770 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3771 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3772 }37733774 async doesExist() {3775 return await this.collection.doesTokenExist(this.tokenId);3776 }37773778 nestingAccount() {3779 return this.collection.helper.util.getTokenAccount(this);3780 }37813782 scheduleAt<T extends UniqueHelper>(3783 executionBlockNumber: number,3784 options: ISchedulerOptions = {},3785 ) {3786 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3787 return new UniqueBaseToken(this.tokenId, scheduledCollection);3788 }37893790 scheduleAfter<T extends UniqueHelper>(3791 blocksBeforeExecution: number,3792 options: ISchedulerOptions = {},3793 ) {3794 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3795 return new UniqueBaseToken(this.tokenId, scheduledCollection);3796 }37973798 getSudo<T extends UniqueHelper>() {3799 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3800 }3801}380238033804export class UniqueNFToken extends UniqueBaseToken {3805 collection: UniqueNFTCollection;38063807 constructor(tokenId: number, collection: UniqueNFTCollection) {3808 super(tokenId, collection);3809 this.collection = collection;3810 }38113812 async getData(blockHashAt?: string) {3813 return await this.collection.getToken(this.tokenId, blockHashAt);3814 }38153816 async getOwner(blockHashAt?: string) {3817 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3818 }38193820 async getTopmostOwner(blockHashAt?: string) {3821 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3822 }38233824 async getChildren(blockHashAt?: string) {3825 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3826 }38273828 async nest(signer: TSigner, toTokenObj: IToken) {3829 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3830 }38313832 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3833 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3834 }38353836 async transfer(signer: TSigner, addressObj: ICrossAccountId) {3837 return await this.collection.transferToken(signer, this.tokenId, addressObj);3838 }38393840 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3841 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3842 }38433844 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3845 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3846 }38473848 async isApproved(toAddressObj: ICrossAccountId) {3849 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3850 }38513852 async burn(signer: TSigner) {3853 return await this.collection.burnToken(signer, this.tokenId);3854 }38553856 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3857 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3858 }38593860 scheduleAt<T extends UniqueHelper>(3861 executionBlockNumber: number,3862 options: ISchedulerOptions = {},3863 ) {3864 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3865 return new UniqueNFToken(this.tokenId, scheduledCollection);3866 }38673868 scheduleAfter<T extends UniqueHelper>(3869 blocksBeforeExecution: number,3870 options: ISchedulerOptions = {},3871 ) {3872 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3873 return new UniqueNFToken(this.tokenId, scheduledCollection);3874 }38753876 getSudo<T extends UniqueHelper>() {3877 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3878 }3879}38803881export class UniqueRFToken extends UniqueBaseToken {3882 collection: UniqueRFTCollection;38833884 constructor(tokenId: number, collection: UniqueRFTCollection) {3885 super(tokenId, collection);3886 this.collection = collection;3887 }38883889 async getData(blockHashAt?: string) {3890 return await this.collection.getToken(this.tokenId, blockHashAt);3891 }38923893 async getOwner(blockHashAt?: string) {3894 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3895 }38963897 async getTop10Owners() {3898 return await this.collection.getTop10TokenOwners(this.tokenId);3899 }39003901 async getTopmostOwner(blockHashAt?: string) {3902 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3903 }39043905 async nest(signer: TSigner, toTokenObj: IToken) {3906 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3907 }39083909 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3910 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3911 }39123913 async getBalance(addressObj: ICrossAccountId) {3914 return await this.collection.getTokenBalance(this.tokenId, addressObj);3915 }39163917 async getTotalPieces() {3918 return await this.collection.getTokenTotalPieces(this.tokenId);3919 }39203921 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {3922 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);3923 }39243925 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {3926 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);3927 }39283929 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3930 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);3931 }39323933 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3934 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);3935 }39363937 async repartition(signer: TSigner, amount: bigint) {3938 return await this.collection.repartitionToken(signer, this.tokenId, amount);3939 }39403941 async burn(signer: TSigner, amount=1n) {3942 return await this.collection.burnToken(signer, this.tokenId, amount);3943 }39443945 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3946 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);3947 }39483949 scheduleAt<T extends UniqueHelper>(3950 executionBlockNumber: number,3951 options: ISchedulerOptions = {},3952 ) {3953 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3954 return new UniqueRFToken(this.tokenId, scheduledCollection);3955 }39563957 scheduleAfter<T extends UniqueHelper>(3958 blocksBeforeExecution: number,3959 options: ISchedulerOptions = {},3960 ) {3961 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3962 return new UniqueRFToken(this.tokenId, scheduledCollection);3963 }39643965 getSudo<T extends UniqueHelper>() {3966 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());3967 }3968}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 {ApiInterfaceEvents, SignerOptions} from '@polkadot/api/types';10import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm, base58Encode, blake2AsU8a} from '@polkadot/util-crypto';11import {IKeyringPair} from '@polkadot/types/types';12import {hexToU8a} from '@polkadot/util/hex';13import {u8aConcat} from '@polkadot/util/u8a';14import {15 IApiListeners,16 IBlock,17 IEvent,18 IChainProperties,19 ICollectionCreationOptions,20 ICollectionLimits,21 ICollectionPermissions,22 ICrossAccountId,23 ICrossAccountIdLower,24 ILogger,25 INestingPermissions,26 IProperty,27 IStakingInfo,28 ISchedulerOptions,29 ISubstrateBalance,30 IToken,31 ITokenPropertyPermission,32 ITransactionResult,33 IUniqueHelperLog,34 TApiAllowedListeners,35 TEthereumAccount,36 TSigner,37 TSubstrateAccount,38 TNetworks,39 IForeignAssetMetadata,40 AcalaAssetMetadata,41 MoonbeamAssetInfo,42 DemocracyStandardAccountVote,43 IEthCrossAccountId,44} from './types';45import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';46import type {Vec} from '@polkadot/types-codec';47import {FrameSystemEventRecord} from '@polkadot/types/lookup';4849export class CrossAccountId implements ICrossAccountId {50 Substrate?: TSubstrateAccount;51 Ethereum?: TEthereumAccount;5253 constructor(account: ICrossAccountId) {54 if (account.Substrate) this.Substrate = account.Substrate;55 if (account.Ethereum) this.Ethereum = account.Ethereum;56 }5758 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {59 switch (domain) {60 case 'Substrate': return new CrossAccountId({Substrate: account.address});61 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();62 }63 }6465 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {66 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});67 }6869 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {70 return encodeAddress(decodeAddress(address), ss58Format);71 }7273 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {74 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});75 }7677 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {78 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);79 return this;80 }8182 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {83 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));84 }8586 toEthereum(): CrossAccountId {87 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});88 return this;89 }9091 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {92 return evmToAddress(address, ss58Format);93 }9495 toSubstrate(ss58Format?: number): CrossAccountId {96 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});97 return this;98 }99100 toLowerCase(): CrossAccountId {101 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();102 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();103 return this;104 }105}106107const nesting = {108 toChecksumAddress(address: string): string {109 if (typeof address === 'undefined') return '';110111 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);112113 address = address.toLowerCase().replace(/^0x/i,'');114 const addressHash = keccakAsHex(address).replace(/^0x/i,'');115 const checksumAddress = ['0x'];116117 for (let i = 0; i < address.length; i++) {118 // If ith character is 8 to f then make it uppercase119 if (parseInt(addressHash[i], 16) > 7) {120 checksumAddress.push(address[i].toUpperCase());121 } else {122 checksumAddress.push(address[i]);123 }124 }125 return checksumAddress.join('');126 },127 tokenIdToAddress(collectionId: number, tokenId: number) {128 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8,'0')}${tokenId.toString(16).padStart(8,'0')}`);129 },130};131132class UniqueUtil {133 static transactionStatus = {134 NOT_READY: 'NotReady',135 FAIL: 'Fail',136 SUCCESS: 'Success',137 };138139 static chainLogType = {140 EXTRINSIC: 'extrinsic',141 RPC: 'rpc',142 };143144 static getTokenAccount(token: IToken): CrossAccountId {145 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});146 }147148 static getTokenAddress(token: IToken): string {149 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);150 }151152 static getDefaultLogger(): ILogger {153 return {154 log(msg: any, level = 'INFO') {155 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));156 },157 level: {158 ERROR: 'ERROR',159 WARNING: 'WARNING',160 INFO: 'INFO',161 },162 };163 }164165 static vec2str(arr: string[] | number[]) {166 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');167 }168169 static str2vec(string: string) {170 if (typeof string !== 'string') return string;171 return Array.from(string).map(x => x.charCodeAt(0));172 }173174 static fromSeed(seed: string, ss58Format = 42) {175 const keyring = new Keyring({type: 'sr25519', ss58Format});176 return keyring.addFromUri(seed);177 }178179 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {180 if (creationResult.status !== this.transactionStatus.SUCCESS) {181 throw Error('Unable to create collection!');182 }183184 let collectionId = null;185 creationResult.result.events.forEach(({event: {data, method, section}}) => {186 if ((section === 'common') && (method === 'CollectionCreated')) {187 collectionId = parseInt(data[0].toString(), 10);188 }189 });190191 if (collectionId === null) {192 throw Error('No CollectionCreated event was found!');193 }194195 return collectionId;196 }197198 static extractTokensFromCreationResult(creationResult: ITransactionResult): {199 success: boolean,200 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],201 } {202 if (creationResult.status !== this.transactionStatus.SUCCESS) {203 throw Error('Unable to create tokens!');204 }205 let success = false;206 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];207 creationResult.result.events.forEach(({event: {data, method, section}}) => {208 if (method === 'ExtrinsicSuccess') {209 success = true;210 } else if ((section === 'common') && (method === 'ItemCreated')) {211 tokens.push({212 collectionId: parseInt(data[0].toString(), 10),213 tokenId: parseInt(data[1].toString(), 10),214 owner: data[2].toHuman(),215 amount: data[3].toBigInt(),216 });217 }218 });219 return {success, tokens};220 }221222 static extractTokensFromBurnResult(burnResult: ITransactionResult): {223 success: boolean,224 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],225 } {226 if (burnResult.status !== this.transactionStatus.SUCCESS) {227 throw Error('Unable to burn tokens!');228 }229 let success = false;230 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];231 burnResult.result.events.forEach(({event: {data, method, section}}) => {232 if (method === 'ExtrinsicSuccess') {233 success = true;234 } else if ((section === 'common') && (method === 'ItemDestroyed')) {235 tokens.push({236 collectionId: parseInt(data[0].toString(), 10),237 tokenId: parseInt(data[1].toString(), 10),238 owner: data[2].toHuman(),239 amount: data[3].toBigInt(),240 });241 }242 });243 return {success, tokens};244 }245246 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {247 let eventId = null;248 events.forEach(({event: {data, method, section}}) => {249 if ((section === expectedSection) && (method === expectedMethod)) {250 eventId = parseInt(data[0].toString(), 10);251 }252 });253254 if (eventId === null) {255 throw Error(`No ${expectedMethod} event was found!`);256 }257 return eventId === collectionId;258 }259260 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {261 const normalizeAddress = (address: string | ICrossAccountId) => {262 if(typeof address === 'string') return address;263 const obj = {} as any;264 Object.keys(address).forEach(k => {265 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];266 });267 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);268 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();269 return address;270 };271 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;272 events.forEach(({event: {data, method, section}}) => {273 if ((section === 'common') && (method === 'Transfer')) {274 const hData = (data as any).toJSON();275 transfer = {276 collectionId: hData[0],277 tokenId: hData[1],278 from: normalizeAddress(hData[2]),279 to: normalizeAddress(hData[3]),280 amount: BigInt(hData[4]),281 };282 }283 });284 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;285 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);286 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);287 isSuccess = isSuccess && amount === transfer.amount;288 return isSuccess;289 }290291 static bigIntToDecimals(number: bigint, decimals = 18) {292 const numberStr = number.toString();293 const dotPos = numberStr.length - decimals;294295 if (dotPos <= 0) {296 return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;297 } else {298 const intPart = numberStr.substring(0, dotPos);299 const fractPart = numberStr.substring(dotPos);300 return intPart + '.' + fractPart;301 }302 }303}304305class UniqueEventHelper {306 private static extractIndex(index: any): [number, number] | string {307 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];308 return index.toJSON();309 }310311 private static extractSub(data: any, subTypes: any): {[key: string]: any} {312 let obj: any = {};313 let index = 0;314315 if (data.entries) {316 for(const [key, value] of data.entries()) {317 obj[key] = this.extractData(value, subTypes[index]);318 index++;319 }320 } else obj = data.toJSON();321322 return obj;323 }324325 private static toHuman(data: any) {326 return data && data.toHuman ? data.toHuman() : `${data}`;327 }328329 private static extractData(data: any, type: any): any {330 if(!type) return this.toHuman(data);331 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();332 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();333 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);334 return this.toHuman(data);335 }336337 public static extractEvents(events: {event: any, phase: any}[]): IEvent[] {338 const parsedEvents: IEvent[] = [];339340 events.forEach((record) => {341 const {event, phase} = record;342 const types = event.typeDef;343344 const eventData: IEvent = {345 section: event.section.toString(),346 method: event.method.toString(),347 index: this.extractIndex(event.index),348 data: [],349 phase: phase.toJSON(),350 };351352 event.data.forEach((val: any, index: number) => {353 eventData.data.push(this.extractData(val, types[index]));354 });355356 parsedEvents.push(eventData);357 });358359 return parsedEvents;360 }361}362363export class ChainHelperBase {364 helperBase: any;365366 transactionStatus = UniqueUtil.transactionStatus;367 chainLogType = UniqueUtil.chainLogType;368 util: typeof UniqueUtil;369 eventHelper: typeof UniqueEventHelper;370 logger: ILogger;371 api: ApiPromise | null;372 forcedNetwork: TNetworks | null;373 network: TNetworks | null;374 wsEndpoint: string | null;375 chainLog: IUniqueHelperLog[];376 children: ChainHelperBase[];377 address: AddressGroup;378 chain: ChainGroup;379380 constructor(logger?: ILogger, helperBase?: any) {381 this.helperBase = helperBase;382383 this.util = UniqueUtil;384 this.eventHelper = UniqueEventHelper;385 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();386 this.logger = logger;387 this.api = null;388 this.forcedNetwork = null;389 this.network = null;390 this.wsEndpoint = null;391 this.chainLog = [];392 this.children = [];393 this.address = new AddressGroup(this);394 this.chain = new ChainGroup(this);395 }396397 clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {398 Object.setPrototypeOf(helperCls.prototype, this);399 const newHelper = new helperCls(this.logger, options);400401 newHelper.api = this.api;402 newHelper.network = this.network;403 newHelper.forceNetwork = this.forceNetwork;404405 this.children.push(newHelper);406407 return newHelper;408 }409410 getEndpoint(): string {411 if (this.wsEndpoint === null) throw Error('No connection was established');412 return this.wsEndpoint;413 }414415 getApi(): ApiPromise {416 if(this.api === null) throw Error('API not initialized');417 return this.api;418 }419420 async subscribeEvents(expectedEvents: {section: string, names: string[]}[]) {421 const collectedEvents: IEvent[] = [];422 const unsubscribe = await this.getApi().query.system.events((events: Vec<FrameSystemEventRecord>) => {423 const ievents = this.eventHelper.extractEvents(events);424 ievents.forEach((event) => {425 expectedEvents.forEach((e => {426 if (event.section === e.section && e.names.includes(event.method)) {427 collectedEvents.push(event);428 }429 }));430 });431 });432 return {unsubscribe: unsubscribe as any, collectedEvents};433 }434435 clearChainLog(): void {436 this.chainLog = [];437 }438439 forceNetwork(value: TNetworks): void {440 this.forcedNetwork = value;441 }442443 async connect(wsEndpoint: string, listeners?: IApiListeners) {444 if (this.api !== null) throw Error('Already connected');445 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);446 this.wsEndpoint = wsEndpoint;447 this.api = api;448 this.network = network;449 }450451 async disconnect() {452 for (const child of this.children) {453 child.clearApi();454 }455456 if (this.api === null) return;457 await this.api.disconnect();458 this.clearApi();459 }460461 clearApi() {462 this.api = null;463 this.network = null;464 }465466 static async detectNetwork(api: ApiPromise): Promise<TNetworks> {467 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;468 const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];469470 if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;471472 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;473 return 'opal';474 }475476 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {477 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});478 await api.isReady;479480 const network = await this.detectNetwork(api);481482 await api.disconnect();483484 return network;485 }486487 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{488 api: ApiPromise;489 network: TNetworks;490 }> {491 if(typeof network === 'undefined' || network === null) network = 'opal';492 const supportedRPC = {493 opal: {494 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,495 },496 quartz: {497 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,498 },499 unique: {500 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,501 },502 rococo: {},503 westend: {},504 moonbeam: {},505 moonriver: {},506 acala: {},507 karura: {},508 westmint: {},509 };510 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);511 const rpc = supportedRPC[network];512513 // TODO: investigate how to replace rpc in runtime514 // api._rpcCore.addUserInterfaces(rpc);515516 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});517518 await api.isReadyOrError;519520 if (typeof listeners === 'undefined') listeners = {};521 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {522 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;523 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);524 }525526 return {api, network};527 }528529 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {530 const {events, status} = data;531 if (status.isReady) {532 return this.transactionStatus.NOT_READY;533 }534 if (status.isBroadcast) {535 return this.transactionStatus.NOT_READY;536 }537 if (status.isInBlock || status.isFinalized) {538 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');539 if (errors.length > 0) {540 return this.transactionStatus.FAIL;541 }542 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {543 return this.transactionStatus.SUCCESS;544 }545 }546547 return this.transactionStatus.FAIL;548 }549550 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {551 const sign = (callback: any) => {552 if(options !== null) return transaction.signAndSend(sender, options, callback);553 return transaction.signAndSend(sender, callback);554 };555 // eslint-disable-next-line no-async-promise-executor556 return new Promise(async (resolve, reject) => {557 try {558 const unsub = await sign((result: any) => {559 const status = this.getTransactionStatus(result);560561 if (status === this.transactionStatus.SUCCESS) {562 this.logger.log(`${label} successful`);563 unsub();564 resolve({result, status, blockHash: result.status.asInBlock.toHuman()});565 } else if (status === this.transactionStatus.FAIL) {566 let moduleError = null;567568 if (result.hasOwnProperty('dispatchError')) {569 const dispatchError = result['dispatchError'];570571 if (dispatchError) {572 if (dispatchError.isModule) {573 const modErr = dispatchError.asModule;574 const errorMeta = dispatchError.registry.findMetaError(modErr);575576 moduleError = `${errorMeta.section}.${errorMeta.name}`;577 } else {578 moduleError = dispatchError.toHuman();579 }580 } else {581 this.logger.log(result, this.logger.level.ERROR);582 }583 }584585 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);586 unsub();587 reject({status, moduleError, result});588 }589 });590 } catch (e) {591 this.logger.log(e, this.logger.level.ERROR);592 reject(e);593 }594 });595 }596597 async signTransactionWithoutSending(signer: TSigner, tx: any) {598 const api = this.getApi();599 const signingInfo = await api.derive.tx.signingInfo(signer.address);600601 tx.sign(signer, {602 blockHash: api.genesisHash,603 genesisHash: api.genesisHash,604 runtimeVersion: api.runtimeVersion,605 nonce: signingInfo.nonce,606 });607608 return tx.toHex();609 }610611 async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {612 const api = this.getApi();613 const signingInfo = await api.derive.tx.signingInfo(signer.address);614615 // We need to sign the tx because616 // unsigned transactions does not have an inclusion fee617 tx.sign(signer, {618 blockHash: api.genesisHash,619 genesisHash: api.genesisHash,620 runtimeVersion: api.runtimeVersion,621 nonce: signingInfo.nonce,622 });623624 if (len === null) {625 return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;626 } else {627 return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;628 }629 }630631 constructApiCall(apiCall: string, params: any[]) {632 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);633 let call = this.getApi() as any;634 for(const part of apiCall.slice(4).split('.')) {635 call = call[part];636 if (!call) {637 const advice = part.includes('_') ? ' Looks like it needs to be converted to camel case.' : '';638 throw Error(`Function ${part} of api call ${apiCall} not found.${advice}`);639 }640 }641 return call(...params);642 }643644 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {645 if(this.api === null) throw Error('API not initialized');646 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);647648 const startTime = (new Date()).getTime();649 let result: ITransactionResult;650 let events: IEvent[] = [];651 try {652 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;653 events = this.eventHelper.extractEvents(result.result.events);654 const errorEvent = events.find((event) => event.method == 'ExecutedFailed' || event.method == 'CreatedFailed');655 if (errorEvent)656 throw Error(errorEvent.method + ': ' + extrinsic);657 }658 catch(e) {659 if(!(e as object).hasOwnProperty('status')) throw e;660 result = e as ITransactionResult;661 }662663 const endTime = (new Date()).getTime();664665 const log = {666 executedAt: endTime,667 executionTime: endTime - startTime,668 type: this.chainLogType.EXTRINSIC,669 status: result.status,670 call: extrinsic,671 signer: this.getSignerAddress(sender),672 params,673 } as IUniqueHelperLog;674675 let errorMessage = '';676677 if(result.status !== this.transactionStatus.SUCCESS) {678 if (result.moduleError) {679 errorMessage = typeof result.moduleError === 'string'680 ? result.moduleError681 : `${Object.keys(result.moduleError)[0]}: ${Object.values(result.moduleError)[0]}`;682 log.moduleError = errorMessage;683 }684 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;685 }686 if(events.length > 0) log.events = events;687688 this.chainLog.push(log);689690 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {691 if (result.moduleError) throw Error(`${errorMessage}`);692 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));693 }694 return result;695 }696697 async callRpc(rpc: string, params?: any[]) {698 if(typeof params === 'undefined') params = [];699 if(this.api === null) throw Error('API not initialized');700 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);701702 const startTime = (new Date()).getTime();703 let result;704 let error = null;705 const log = {706 type: this.chainLogType.RPC,707 call: rpc,708 params,709 } as IUniqueHelperLog;710711 try {712 result = await this.constructApiCall(rpc, params);713 }714 catch(e) {715 error = e;716 }717718 const endTime = (new Date()).getTime();719720 log.executedAt = endTime;721 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';722 log.executionTime = endTime - startTime;723724 this.chainLog.push(log);725726 if(error !== null) throw error;727728 return result;729 }730731 getSignerAddress(signer: IKeyringPair | string): string {732 if(typeof signer === 'string') return signer;733 return signer.address;734 }735736 fetchAllPalletNames(): string[] {737 if(this.api === null) throw Error('API not initialized');738 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());739 }740741 fetchMissingPalletNames(requiredPallets: string[]): string[] {742 const palletNames = this.fetchAllPalletNames();743 return requiredPallets.filter(p => !palletNames.includes(p));744 }745}746747748class HelperGroup<T extends ChainHelperBase> {749 helper: T;750751 constructor(uniqueHelper: T) {752 this.helper = uniqueHelper;753 }754}755756757class CollectionGroup extends HelperGroup<UniqueHelper> {758 /**759 * Get number of blocks when sponsored transaction is available.760 *761 * @param collectionId ID of collection762 * @param tokenId ID of token763 * @param addressObj address for which the sponsorship is checked764 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});765 * @returns number of blocks or null if sponsorship hasn't been set766 */767 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {768 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();769 }770771 /**772 * Get the number of created collections.773 *774 * @returns number of created collections775 */776 async getTotalCount(): Promise<number> {777 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();778 }779780 /**781 * Get information about the collection with additional data,782 * including the number of tokens it contains, its administrators,783 * the normalized address of the collection's owner, and decoded name and description.784 *785 * @param collectionId ID of collection786 * @example await getData(2)787 * @returns collection information object788 */789 async getData(collectionId: number): Promise<{790 id: number;791 name: string;792 description: string;793 tokensCount: number;794 admins: CrossAccountId[];795 normalizedOwner: TSubstrateAccount;796 raw: any797 } | null> {798 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);799 const humanCollection = collection.toHuman(), collectionData = {800 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],801 raw: humanCollection,802 } as any, jsonCollection = collection.toJSON();803 if (humanCollection === null) return null;804 collectionData.raw.limits = jsonCollection.limits;805 collectionData.raw.permissions = jsonCollection.permissions;806 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);807 for (const key of ['name', 'description']) {808 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);809 }810811 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))812 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)813 : 0;814 collectionData.admins = await this.getAdmins(collectionId);815816 return collectionData;817 }818819 /**820 * Get the addresses of the collection's administrators, optionally normalized.821 *822 * @param collectionId ID of collection823 * @param normalize whether to normalize the addresses to the default ss58 format824 * @example await getAdmins(1)825 * @returns array of administrators826 */827 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {828 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();829830 return normalize831 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())832 : admins;833 }834835 /**836 * Get the addresses added to the collection allow-list, optionally normalized.837 * @param collectionId ID of collection838 * @param normalize whether to normalize the addresses to the default ss58 format839 * @example await getAllowList(1)840 * @returns array of allow-listed addresses841 */842 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {843 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();844 return normalize845 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())846 : allowListed;847 }848849 /**850 * Get the effective limits of the collection instead of null for default values851 *852 * @param collectionId ID of collection853 * @example await getEffectiveLimits(2)854 * @returns object of collection limits855 */856 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {857 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();858 }859860 /**861 * Burns the collection if the signer has sufficient permissions and collection is empty.862 *863 * @param signer keyring of signer864 * @param collectionId ID of collection865 * @example await helper.collection.burn(aliceKeyring, 3);866 * @returns ```true``` if extrinsic success, otherwise ```false```867 */868 async burn(signer: TSigner, collectionId: number): Promise<boolean> {869 const result = await this.helper.executeExtrinsic(870 signer,871 'api.tx.unique.destroyCollection', [collectionId],872 true,873 );874875 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');876 }877878 /**879 * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.880 *881 * @param signer keyring of signer882 * @param collectionId ID of collection883 * @param sponsorAddress Sponsor substrate address884 * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")885 * @returns ```true``` if extrinsic success, otherwise ```false```886 */887 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {888 const result = await this.helper.executeExtrinsic(889 signer,890 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],891 true,892 );893894 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorSet');895 }896897 /**898 * Confirms consent to sponsor the collection on behalf of the signer.899 *900 * @param signer keyring of signer901 * @param collectionId ID of collection902 * @example confirmSponsorship(aliceKeyring, 10)903 * @returns ```true``` if extrinsic success, otherwise ```false```904 */905 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {906 const result = await this.helper.executeExtrinsic(907 signer,908 'api.tx.unique.confirmSponsorship', [collectionId],909 true,910 );911912 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'SponsorshipConfirmed');913 }914915 /**916 * Removes the sponsor of a collection, regardless if it consented or not.917 *918 * @param signer keyring of signer919 * @param collectionId ID of collection920 * @example removeSponsor(aliceKeyring, 10)921 * @returns ```true``` if extrinsic success, otherwise ```false```922 */923 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {924 const result = await this.helper.executeExtrinsic(925 signer,926 'api.tx.unique.removeCollectionSponsor', [collectionId],927 true,928 );929930 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorRemoved');931 }932933 /**934 * Sets the limits of the collection. At least one limit must be specified for a correct call.935 *936 * @param signer keyring of signer937 * @param collectionId ID of collection938 * @param limits collection limits object939 * @example940 * await setLimits(941 * aliceKeyring,942 * 10,943 * {944 * sponsorTransferTimeout: 0,945 * ownerCanDestroy: false946 * }947 * )948 * @returns ```true``` if extrinsic success, otherwise ```false```949 */950 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {951 const result = await this.helper.executeExtrinsic(952 signer,953 'api.tx.unique.setCollectionLimits', [collectionId, limits],954 true,955 );956957 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionLimitSet');958 }959960 /**961 * Changes the owner of the collection to the new Substrate address.962 *963 * @param signer keyring of signer964 * @param collectionId ID of collection965 * @param ownerAddress substrate address of new owner966 * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")967 * @returns ```true``` if extrinsic success, otherwise ```false```968 */969 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {970 const result = await this.helper.executeExtrinsic(971 signer,972 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],973 true,974 );975976 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionOwnerChanged');977 }978979 /**980 * Adds a collection administrator.981 *982 * @param signer keyring of signer983 * @param collectionId ID of collection984 * @param adminAddressObj Administrator address (substrate or ethereum)985 * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})986 * @returns ```true``` if extrinsic success, otherwise ```false```987 */988 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {989 const result = await this.helper.executeExtrinsic(990 signer,991 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],992 true,993 );994995 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminAdded');996 }997998 /**999 * Removes a collection administrator.1000 *1001 * @param signer keyring of signer1002 * @param collectionId ID of collection1003 * @param adminAddressObj Administrator address (substrate or ethereum)1004 * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})1005 * @returns ```true``` if extrinsic success, otherwise ```false```1006 */1007 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {1008 const result = await this.helper.executeExtrinsic(1009 signer,1010 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],1011 true,1012 );10131014 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminRemoved');1015 }10161017 /**1018 * Check if user is in allow list.1019 *1020 * @param collectionId ID of collection1021 * @param user Account to check1022 * @example await getAdmins(1)1023 * @returns is user in allow list1024 */1025 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {1026 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();1027 }10281029 /**1030 * Adds an address to allow list1031 * @param signer keyring of signer1032 * @param collectionId ID of collection1033 * @param addressObj address to add to the allow list1034 * @returns ```true``` if extrinsic success, otherwise ```false```1035 */1036 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1037 const result = await this.helper.executeExtrinsic(1038 signer,1039 'api.tx.unique.addToAllowList', [collectionId, addressObj],1040 true,1041 );10421043 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressAdded');1044 }10451046 /**1047 * Removes an address from allow list1048 *1049 * @param signer keyring of signer1050 * @param collectionId ID of collection1051 * @param addressObj address to remove from the allow list1052 * @returns ```true``` if extrinsic success, otherwise ```false```1053 */1054 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1055 const result = await this.helper.executeExtrinsic(1056 signer,1057 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],1058 true,1059 );10601061 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressRemoved');1062 }10631064 /**1065 * Sets onchain permissions for selected collection.1066 *1067 * @param signer keyring of signer1068 * @param collectionId ID of collection1069 * @param permissions collection permissions object1070 * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});1071 * @returns ```true``` if extrinsic success, otherwise ```false```1072 */1073 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {1074 const result = await this.helper.executeExtrinsic(1075 signer,1076 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],1077 true,1078 );10791080 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPermissionSet');1081 }10821083 /**1084 * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.1085 *1086 * @param signer keyring of signer1087 * @param collectionId ID of collection1088 * @param permissions nesting permissions object1089 * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});1090 * @returns ```true``` if extrinsic success, otherwise ```false```1091 */1092 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1093 return await this.setPermissions(signer, collectionId, {nesting: permissions});1094 }10951096 /**1097 * Disables nesting for selected collection.1098 *1099 * @param signer keyring of signer1100 * @param collectionId ID of collection1101 * @example disableNesting(aliceKeyring, 10);1102 * @returns ```true``` if extrinsic success, otherwise ```false```1103 */1104 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1105 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1106 }11071108 /**1109 * Sets onchain properties to the collection.1110 *1111 * @param signer keyring of signer1112 * @param collectionId ID of collection1113 * @param properties array of property objects1114 * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);1115 * @returns ```true``` if extrinsic success, otherwise ```false```1116 */1117 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1118 const result = await this.helper.executeExtrinsic(1119 signer,1120 'api.tx.unique.setCollectionProperties', [collectionId, properties],1121 true,1122 );11231124 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1125 }11261127 /**1128 * Get collection properties.1129 *1130 * @param collectionId ID of collection1131 * @param propertyKeys optionally filter the returned properties to only these keys1132 * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1133 * @returns array of key-value pairs1134 */1135 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1136 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1137 }11381139 async getPropertiesConsumedSpace(collectionId: number): Promise<number> {1140 const api = this.helper.getApi();1141 const props = (await api.query.common.collectionProperties(collectionId)).toJSON();11421143 return (props! as any).consumedSpace;1144 }11451146 async getCollectionOptions(collectionId: number) {1147 return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1148 }11491150 /**1151 * Deletes onchain properties from the collection.1152 *1153 * @param signer keyring of signer1154 * @param collectionId ID of collection1155 * @param propertyKeys array of property keys to delete1156 * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1157 * @returns ```true``` if extrinsic success, otherwise ```false```1158 */1159 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1160 const result = await this.helper.executeExtrinsic(1161 signer,1162 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1163 true,1164 );11651166 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1167 }11681169 /**1170 * Changes the owner of the token.1171 *1172 * @param signer keyring of signer1173 * @param collectionId ID of collection1174 * @param tokenId ID of token1175 * @param addressObj address of a new owner1176 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1177 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1178 * @returns true if the token success, otherwise false1179 */1180 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1181 const result = await this.helper.executeExtrinsic(1182 signer,1183 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1184 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1185 );11861187 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1188 }11891190 /**1191 *1192 * Change ownership of a token(s) on behalf of the owner.1193 *1194 * @param signer keyring of signer1195 * @param collectionId ID of collection1196 * @param tokenId ID of token1197 * @param fromAddressObj address on behalf of which the token will be sent1198 * @param toAddressObj new token owner1199 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1200 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1201 * @returns true if the token success, otherwise false1202 */1203 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1204 const result = await this.helper.executeExtrinsic(1205 signer,1206 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1207 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1208 );1209 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1210 }12111212 /**1213 *1214 * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1215 *1216 * @param signer keyring of signer1217 * @param collectionId ID of collection1218 * @param tokenId ID of token1219 * @param amount amount of tokens to be burned. For NFT must be set to 1n1220 * @example burnToken(aliceKeyring, 10, 5);1221 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1222 */1223 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1224 const burnResult = await this.helper.executeExtrinsic(1225 signer,1226 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1227 true, // `Unable to burn token for ${label}`,1228 );1229 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1230 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1231 return burnedTokens.success;1232 }12331234 /**1235 * Destroys a concrete instance of NFT on behalf of the owner1236 *1237 * @param signer keyring of signer1238 * @param collectionId ID of collection1239 * @param tokenId ID of token1240 * @param fromAddressObj address on behalf of which the token will be burnt1241 * @param amount amount of tokens to be burned. For NFT must be set to 1n1242 * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1243 * @returns ```true``` if extrinsic success, otherwise ```false```1244 */1245 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1246 const burnResult = await this.helper.executeExtrinsic(1247 signer,1248 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1249 true, // `Unable to burn token from for ${label}`,1250 );1251 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1252 return burnedTokens.success && burnedTokens.tokens.length > 0;1253 }12541255 /**1256 * Set, change, or remove approved address to transfer the ownership of the NFT.1257 *1258 * @param signer keyring of signer1259 * @param collectionId ID of collection1260 * @param tokenId ID of token1261 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1262 * @param amount amount of token to be approved. For NFT must be set to 1n1263 * @returns ```true``` if extrinsic success, otherwise ```false```1264 */1265 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1266 const approveResult = await this.helper.executeExtrinsic(1267 signer,1268 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1269 true, // `Unable to approve token for ${label}`,1270 );12711272 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1273 }12741275 /**1276 * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1277 *1278 * @param signer keyring of signer1279 * @param collectionId ID of collection1280 * @param tokenId ID of token1281 * @param fromAddressObj Signer's Ethereum address containing her tokens1282 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1283 * @param amount amount of token to be approved. For NFT must be set to 1n1284 * @returns ```true``` if extrinsic success, otherwise ```false```1285 */1286 async approveTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1287 const approveResult = await this.helper.executeExtrinsic(1288 signer,1289 'api.tx.unique.approveFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1290 true, // `Unable to approve token for ${label}`,1291 );12921293 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1294 }12951296 /**1297 * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1298 *1299 * @param signer keyring of signer1300 * @param collectionId ID of collection1301 * @param tokenId ID of token1302 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1303 * @param amount amount of token to be approved. For NFT must be set to 1n1304 * @returns ```true``` if extrinsic success, otherwise ```false```1305 */1306 async approveTokenFromEth(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1307 const ethMirror = CrossAccountId.fromKeyring(signer).toEthereum();1308 return await this.approveTokenFrom(signer, collectionId, tokenId, ethMirror, toAddressObj, amount);1309 }13101311 /**1312 * Get the amount of token pieces approved to transfer or burn. Normally 0.1313 *1314 * @param collectionId ID of collection1315 * @param tokenId ID of token1316 * @param toAccountObj address which is approved to use token pieces1317 * @param fromAccountObj address which may have allowed the use of its owned tokens1318 * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1319 * @returns number of approved to transfer pieces1320 */1321 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1322 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1323 }13241325 /**1326 * Get the last created token ID in a collection1327 *1328 * @param collectionId ID of collection1329 * @example getLastTokenId(10);1330 * @returns id of the last created token1331 */1332 async getLastTokenId(collectionId: number): Promise<number> {1333 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1334 }13351336 /**1337 * Check if token exists1338 *1339 * @param collectionId ID of collection1340 * @param tokenId ID of token1341 * @example doesTokenExist(10, 20);1342 * @returns true if the token exists, otherwise false1343 */1344 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1345 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1346 }1347}13481349class NFTnRFT extends CollectionGroup {1350 /**1351 * Get tokens owned by account1352 *1353 * @param collectionId ID of collection1354 * @param addressObj tokens owner1355 * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1356 * @returns array of token ids owned by account1357 */1358 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1359 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1360 }13611362 /**1363 * Get token data1364 *1365 * @param collectionId ID of collection1366 * @param tokenId ID of token1367 * @param propertyKeys optionally filter the token properties to only these keys1368 * @param blockHashAt optionally query the data at some block with this hash1369 * @example getToken(10, 5);1370 * @returns human readable token data1371 */1372 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1373 properties: IProperty[];1374 owner: CrossAccountId;1375 normalizedOwner: CrossAccountId;1376 }| null> {1377 let tokenData;1378 if(typeof blockHashAt === 'undefined') {1379 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1380 }1381 else {1382 if(propertyKeys.length == 0) {1383 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1384 if(!collection) return null;1385 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1386 }1387 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1388 }1389 tokenData = tokenData.toHuman();1390 if (tokenData === null || tokenData.owner === null) return null;1391 const owner = {} as any;1392 for (const key of Object.keys(tokenData.owner)) {1393 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'1394 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])1395 : tokenData.owner[key];1396 }1397 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1398 return tokenData;1399 }14001401 /**1402 * Get token's owner1403 * @param collectionId ID of collection1404 * @param tokenId ID of token1405 * @param blockHashAt optionally query the data at the block with this hash1406 * @example getTokenOwner(10, 5);1407 * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1408 */1409 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1410 let owner;1411 if (typeof blockHashAt === 'undefined') {1412 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1413 } else {1414 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1415 }1416 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1417 }14181419 /**1420 * Recursively find the address that owns the token1421 * @param collectionId ID of collection1422 * @param tokenId ID of token1423 * @param blockHashAt1424 * @example getTokenTopmostOwner(10, 5);1425 * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1426 */1427 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1428 let owner;1429 if (typeof blockHashAt === 'undefined') {1430 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1431 } else {1432 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1433 }14341435 if (owner === null) return null;14361437 return owner.toHuman();1438 }14391440 /**1441 * Nest one token into another1442 * @param signer keyring of signer1443 * @param tokenObj token to be nested1444 * @param rootTokenObj token to be parent1445 * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1446 * @returns ```true``` if extrinsic success, otherwise ```false```1447 */1448 async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1449 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1450 const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1451 if(!result) {1452 throw Error('Unable to nest token!');1453 }1454 return result;1455 }14561457 /**1458 * Remove token from nested state1459 * @param signer keyring of signer1460 * @param tokenObj token to unnest1461 * @param rootTokenObj parent of a token1462 * @param toAddressObj address of a new token owner1463 * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1464 * @returns ```true``` if extrinsic success, otherwise ```false```1465 */1466 async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1467 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1468 const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1469 if(!result) {1470 throw Error('Unable to unnest token!');1471 }1472 return result;1473 }14741475 /**1476 * Set permissions to change token properties1477 *1478 * @param signer keyring of signer1479 * @param collectionId ID of collection1480 * @param permissions permissions to change a property by the collection admin or token owner1481 * @example setTokenPropertyPermissions(1482 * aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1483 * )1484 * @returns true if extrinsic success otherwise false1485 */1486 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1487 const result = await this.helper.executeExtrinsic(1488 signer,1489 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1490 true,1491 );14921493 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1494 }14951496 /**1497 * Get token property permissions.1498 *1499 * @param collectionId ID of collection1500 * @param propertyKeys optionally filter the returned property permissions to only these keys1501 * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1502 * @returns array of key-permission pairs1503 */1504 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1505 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1506 }15071508 /**1509 * Set token properties1510 *1511 * @param signer keyring of signer1512 * @param collectionId ID of collection1513 * @param tokenId ID of token1514 * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1515 * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1516 * @returns ```true``` if extrinsic success, otherwise ```false```1517 */1518 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1519 const result = await this.helper.executeExtrinsic(1520 signer,1521 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1522 true,1523 );15241525 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1526 }15271528 /**1529 * Get properties, metadata assigned to a token.1530 *1531 * @param collectionId ID of collection1532 * @param tokenId ID of token1533 * @param propertyKeys optionally filter the returned properties to only these keys1534 * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1535 * @returns array of key-value pairs1536 */1537 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1538 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1539 }15401541 /**1542 * Delete the provided properties of a token1543 * @param signer keyring of signer1544 * @param collectionId ID of collection1545 * @param tokenId ID of token1546 * @param propertyKeys property keys to be deleted1547 * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1548 * @returns ```true``` if extrinsic success, otherwise ```false```1549 */1550 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1551 const result = await this.helper.executeExtrinsic(1552 signer,1553 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1554 true,1555 );15561557 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1558 }15591560 /**1561 * Mint new collection1562 *1563 * @param signer keyring of signer1564 * @param collectionOptions basic collection options and properties1565 * @param mode NFT or RFT type of a collection1566 * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1567 * @returns object of the created collection1568 */1569 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1570 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1571 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1572 for (const key of ['name', 'description', 'tokenPrefix']) {1573 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);1574 }1575 const creationResult = await this.helper.executeExtrinsic(1576 signer,1577 'api.tx.unique.createCollectionEx', [collectionOptions],1578 true, // errorLabel,1579 );1580 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1581 }15821583 getCollectionObject(_collectionId: number): any {1584 return null;1585 }15861587 getTokenObject(_collectionId: number, _tokenId: number): any {1588 return null;1589 }15901591 /**1592 * Tells whether the given `owner` approves the `operator`.1593 * @param collectionId ID of collection1594 * @param owner owner address1595 * @param operator operator addrees1596 * @returns true if operator is enabled1597 */1598 async allowanceForAll(collectionId: number, owner: ICrossAccountId, operator: ICrossAccountId): Promise<boolean> {1599 return (await this.helper.callRpc('api.rpc.unique.allowanceForAll', [collectionId, owner, operator])).toJSON();1600 }16011602 /** Sets or unsets the approval of a given operator.1603 * The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1604 * @param operator Operator1605 * @param approved Should operator status be granted or revoked?1606 * @returns ```true``` if extrinsic success, otherwise ```false```1607 */1608 async setAllowanceForAll(signer: TSigner, collectionId: number, operator: ICrossAccountId, approved: boolean): Promise<boolean> {1609 const result = await this.helper.executeExtrinsic(1610 signer,1611 'api.tx.unique.setAllowanceForAll', [collectionId, operator, approved],1612 true,1613 );1614 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'ApprovedForAll');1615 }1616}161716181619class NFTGroup extends NFTnRFT {1620 /**1621 * Get collection object1622 * @param collectionId ID of collection1623 * @example getCollectionObject(2);1624 * @returns instance of UniqueNFTCollection1625 */1626 getCollectionObject(collectionId: number): UniqueNFTCollection {1627 return new UniqueNFTCollection(collectionId, this.helper);1628 }16291630 /**1631 * Get token object1632 * @param collectionId ID of collection1633 * @param tokenId ID of token1634 * @example getTokenObject(10, 5);1635 * @returns instance of UniqueNFTToken1636 */1637 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1638 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1639 }16401641 /**1642 * Is token approved to transfer1643 * @param collectionId ID of collection1644 * @param tokenId ID of token1645 * @param toAccountObj address to be approved1646 * @returns ```true``` if extrinsic success, otherwise ```false```1647 */1648 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1649 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1650 }16511652 /**1653 * Changes the owner of the token.1654 *1655 * @param signer keyring of signer1656 * @param collectionId ID of collection1657 * @param tokenId ID of token1658 * @param addressObj address of a new owner1659 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1660 * @returns ```true``` if extrinsic success, otherwise ```false```1661 */1662 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1663 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1664 }16651666 /**1667 *1668 * Change ownership of a NFT on behalf of the owner.1669 *1670 * @param signer keyring of signer1671 * @param collectionId ID of collection1672 * @param tokenId ID of token1673 * @param fromAddressObj address on behalf of which the token will be sent1674 * @param toAddressObj new token owner1675 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1676 * @returns ```true``` if extrinsic success, otherwise ```false```1677 */1678 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1679 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1680 }16811682 /**1683 * Get tokens nested in the provided token1684 * @param collectionId ID of collection1685 * @param tokenId ID of token1686 * @param blockHashAt optionally query the data at the block with this hash1687 * @example getTokenChildren(10, 5);1688 * @returns tokens whose depth of nesting is <= 51689 */1690 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1691 let children;1692 if(typeof blockHashAt === 'undefined') {1693 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1694 } else {1695 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1696 }16971698 return children.toJSON().map((x: any) => {1699 return {collectionId: x.collection, tokenId: x.token};1700 });1701 }17021703 /**1704 * Mint new collection1705 * @param signer keyring of signer1706 * @param collectionOptions Collection options1707 * @example1708 * mintCollection(aliceKeyring, {1709 * name: 'New',1710 * description: 'New collection',1711 * tokenPrefix: 'NEW',1712 * })1713 * @returns object of the created collection1714 */1715 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1716 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1717 }17181719 /**1720 * Mint new token1721 * @param signer keyring of signer1722 * @param data token data1723 * @returns created token object1724 */1725 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1726 const creationResult = await this.helper.executeExtrinsic(1727 signer,1728 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1729 nft: {1730 properties: data.properties,1731 },1732 }],1733 true,1734 );1735 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1736 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1737 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1738 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1739 }17401741 /**1742 * Mint multiple NFT tokens1743 * @param signer keyring of signer1744 * @param collectionId ID of collection1745 * @param tokens array of tokens with owner and properties1746 * @example1747 * mintMultipleTokens(aliceKeyring, 10, [{1748 * owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1749 * properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1750 * },{1751 * owner: {Ethereum: "0x9F0583DbB855d..."},1752 * properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1753 * }]);1754 * @returns ```true``` if extrinsic success, otherwise ```false```1755 */1756 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1757 const creationResult = await this.helper.executeExtrinsic(1758 signer,1759 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1760 true,1761 );1762 const collection = this.getCollectionObject(collectionId);1763 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1764 }17651766 /**1767 * Mint multiple NFT tokens with one owner1768 * @param signer keyring of signer1769 * @param collectionId ID of collection1770 * @param owner tokens owner1771 * @param tokens array of tokens with owner and properties1772 * @example1773 * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1774 * properties: [{1775 * key: "gender",1776 * value: "female",1777 * },{1778 * key: "age",1779 * value: "33",1780 * }],1781 * }]);1782 * @returns array of newly created tokens1783 */1784 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1785 const rawTokens = [];1786 for (const token of tokens) {1787 const raw = {NFT: {properties: token.properties}};1788 rawTokens.push(raw);1789 }1790 const creationResult = await this.helper.executeExtrinsic(1791 signer,1792 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1793 true,1794 );1795 const collection = this.getCollectionObject(collectionId);1796 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1797 }17981799 /**1800 * Set, change, or remove approved address to transfer the ownership of the NFT.1801 *1802 * @param signer keyring of signer1803 * @param collectionId ID of collection1804 * @param tokenId ID of token1805 * @param toAddressObj address to approve1806 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1807 * @returns ```true``` if extrinsic success, otherwise ```false```1808 */1809 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1810 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1811 }1812}181318141815class RFTGroup extends NFTnRFT {1816 /**1817 * Get collection object1818 * @param collectionId ID of collection1819 * @example getCollectionObject(2);1820 * @returns instance of UniqueRFTCollection1821 */1822 getCollectionObject(collectionId: number): UniqueRFTCollection {1823 return new UniqueRFTCollection(collectionId, this.helper);1824 }18251826 /**1827 * Get token object1828 * @param collectionId ID of collection1829 * @param tokenId ID of token1830 * @example getTokenObject(10, 5);1831 * @returns instance of UniqueNFTToken1832 */1833 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1834 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1835 }18361837 /**1838 * Get top 10 token owners with the largest number of pieces1839 * @param collectionId ID of collection1840 * @param tokenId ID of token1841 * @example getTokenTop10Owners(10, 5);1842 * @returns array of top 10 owners1843 */1844 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1845 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1846 }18471848 /**1849 * Get number of pieces owned by address1850 * @param collectionId ID of collection1851 * @param tokenId ID of token1852 * @param addressObj address token owner1853 * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1854 * @returns number of pieces ownerd by address1855 */1856 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1857 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1858 }18591860 /**1861 * Transfer pieces of token to another address1862 * @param signer keyring of signer1863 * @param collectionId ID of collection1864 * @param tokenId ID of token1865 * @param addressObj address of a new owner1866 * @param amount number of pieces to be transfered1867 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1868 * @returns ```true``` if extrinsic success, otherwise ```false```1869 */1870 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1871 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1872 }18731874 /**1875 * Change ownership of some pieces of RFT on behalf of the owner.1876 * @param signer keyring of signer1877 * @param collectionId ID of collection1878 * @param tokenId ID of token1879 * @param fromAddressObj address on behalf of which the token will be sent1880 * @param toAddressObj new token owner1881 * @param amount number of pieces to be transfered1882 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1883 * @returns ```true``` if extrinsic success, otherwise ```false```1884 */1885 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1886 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1887 }18881889 /**1890 * Mint new collection1891 * @param signer keyring of signer1892 * @param collectionOptions Collection options1893 * @example1894 * mintCollection(aliceKeyring, {1895 * name: 'New',1896 * description: 'New collection',1897 * tokenPrefix: 'NEW',1898 * })1899 * @returns object of the created collection1900 */1901 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1902 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1903 }19041905 /**1906 * Mint new token1907 * @param signer keyring of signer1908 * @param data token data1909 * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1910 * @returns created token object1911 */1912 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1913 const creationResult = await this.helper.executeExtrinsic(1914 signer,1915 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1916 refungible: {1917 pieces: data.pieces,1918 properties: data.properties,1919 },1920 }],1921 true,1922 );1923 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1924 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1925 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1926 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1927 }19281929 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1930 throw Error('Not implemented');1931 const creationResult = await this.helper.executeExtrinsic(1932 signer,1933 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1934 true, // `Unable to mint RFT tokens for ${label}`,1935 );1936 const collection = this.getCollectionObject(collectionId);1937 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1938 }19391940 /**1941 * Mint multiple RFT tokens with one owner1942 * @param signer keyring of signer1943 * @param collectionId ID of collection1944 * @param owner tokens owner1945 * @param tokens array of tokens with properties and pieces1946 * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1947 * @returns array of newly created RFT tokens1948 */1949 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1950 const rawTokens = [];1951 for (const token of tokens) {1952 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1953 rawTokens.push(raw);1954 }1955 const creationResult = await this.helper.executeExtrinsic(1956 signer,1957 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1958 true,1959 );1960 const collection = this.getCollectionObject(collectionId);1961 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1962 }19631964 /**1965 * Destroys a concrete instance of RFT.1966 * @param signer keyring of signer1967 * @param collectionId ID of collection1968 * @param tokenId ID of token1969 * @param amount number of pieces to be burnt1970 * @example burnToken(aliceKeyring, 10, 5);1971 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1972 */1973 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1974 return await super.burnToken(signer, collectionId, tokenId, amount);1975 }19761977 /**1978 * Destroys a concrete instance of RFT on behalf of the owner.1979 * @param signer keyring of signer1980 * @param collectionId ID of collection1981 * @param tokenId ID of token1982 * @param fromAddressObj address on behalf of which the token will be burnt1983 * @param amount number of pieces to be burnt1984 * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1985 * @returns ```true``` if extrinsic success, otherwise ```false```1986 */1987 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1988 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1989 }19901991 /**1992 * Set, change, or remove approved address to transfer the ownership of the RFT.1993 *1994 * @param signer keyring of signer1995 * @param collectionId ID of collection1996 * @param tokenId ID of token1997 * @param toAddressObj address to approve1998 * @param amount number of pieces to be approved1999 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);2000 * @returns true if the token success, otherwise false2001 */2002 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {2003 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);2004 }20052006 /**2007 * Get total number of pieces2008 * @param collectionId ID of collection2009 * @param tokenId ID of token2010 * @example getTokenTotalPieces(10, 5);2011 * @returns number of pieces2012 */2013 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {2014 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();2015 }20162017 /**2018 * Change number of token pieces. Signer must be the owner of all token pieces.2019 * @param signer keyring of signer2020 * @param collectionId ID of collection2021 * @param tokenId ID of token2022 * @param amount new number of pieces2023 * @example repartitionToken(aliceKeyring, 10, 5, 12345n);2024 * @returns true if the repartion was success, otherwise false2025 */2026 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {2027 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);2028 const repartitionResult = await this.helper.executeExtrinsic(2029 signer,2030 'api.tx.unique.repartition', [collectionId, tokenId, amount],2031 true,2032 );2033 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');2034 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');2035 }2036}203720382039class FTGroup extends CollectionGroup {2040 /**2041 * Get collection object2042 * @param collectionId ID of collection2043 * @example getCollectionObject(2);2044 * @returns instance of UniqueFTCollection2045 */2046 getCollectionObject(collectionId: number): UniqueFTCollection {2047 return new UniqueFTCollection(collectionId, this.helper);2048 }20492050 /**2051 * Mint new fungible collection2052 * @param signer keyring of signer2053 * @param collectionOptions Collection options2054 * @param decimalPoints number of token decimals2055 * @example2056 * mintCollection(aliceKeyring, {2057 * name: 'New',2058 * description: 'New collection',2059 * tokenPrefix: 'NEW',2060 * }, 18)2061 * @returns newly created fungible collection2062 */2063 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {2064 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object2065 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');2066 collectionOptions.mode = {fungible: decimalPoints};2067 for (const key of ['name', 'description', 'tokenPrefix']) {2068 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);2069 }2070 const creationResult = await this.helper.executeExtrinsic(2071 signer,2072 'api.tx.unique.createCollectionEx', [collectionOptions],2073 true,2074 );2075 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));2076 }20772078 /**2079 * Mint tokens2080 * @param signer keyring of signer2081 * @param collectionId ID of collection2082 * @param owner address owner of new tokens2083 * @param amount amount of tokens to be meanted2084 * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);2085 * @returns ```true``` if extrinsic success, otherwise ```false```2086 */2087 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {2088 const creationResult = await this.helper.executeExtrinsic(2089 signer,2090 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {2091 fungible: {2092 value: amount,2093 },2094 }],2095 true, // `Unable to mint fungible tokens for ${label}`,2096 );2097 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2098 }20992100 /**2101 * Mint multiple Fungible tokens with one owner2102 * @param signer keyring of signer2103 * @param collectionId ID of collection2104 * @param owner tokens owner2105 * @param tokens array of tokens with properties and pieces2106 * @returns ```true``` if extrinsic success, otherwise ```false```2107 */2108 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {2109 const rawTokens = [];2110 for (const token of tokens) {2111 const raw = {Fungible: {Value: token.value}};2112 rawTokens.push(raw);2113 }2114 const creationResult = await this.helper.executeExtrinsic(2115 signer,2116 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],2117 true,2118 );2119 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2120 }21212122 /**2123 * Get the top 10 owners with the largest balance for the Fungible collection2124 * @param collectionId ID of collection2125 * @example getTop10Owners(10);2126 * @returns array of ```ICrossAccountId```2127 */2128 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {2129 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);2130 }21312132 /**2133 * Get account balance2134 * @param collectionId ID of collection2135 * @param addressObj address of owner2136 * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})2137 * @returns amount of fungible tokens owned by address2138 */2139 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {2140 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();2141 }21422143 /**2144 * Transfer tokens to address2145 * @param signer keyring of signer2146 * @param collectionId ID of collection2147 * @param toAddressObj address recipient2148 * @param amount amount of tokens to be sent2149 * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2150 * @returns ```true``` if extrinsic success, otherwise ```false```2151 */2152 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2153 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);2154 }21552156 /**2157 * Transfer some tokens on behalf of the owner.2158 * @param signer keyring of signer2159 * @param collectionId ID of collection2160 * @param fromAddressObj address on behalf of which tokens will be sent2161 * @param toAddressObj address where token to be sent2162 * @param amount number of tokens to be sent2163 * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);2164 * @returns ```true``` if extrinsic success, otherwise ```false```2165 */2166 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2167 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2168 }21692170 /**2171 * Destroy some amount of tokens2172 * @param signer keyring of signer2173 * @param collectionId ID of collection2174 * @param amount amount of tokens to be destroyed2175 * @example burnTokens(aliceKeyring, 10, 1000n);2176 * @returns ```true``` if extrinsic success, otherwise ```false```2177 */2178 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {2179 return await super.burnToken(signer, collectionId, 0, amount);2180 }21812182 /**2183 * Burn some tokens on behalf of the owner.2184 * @param signer keyring of signer2185 * @param collectionId ID of collection2186 * @param fromAddressObj address on behalf of which tokens will be burnt2187 * @param amount amount of tokens to be burnt2188 * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2189 * @returns ```true``` if extrinsic success, otherwise ```false```2190 */2191 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {2192 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2193 }21942195 /**2196 * Get total collection supply2197 * @param collectionId2198 * @returns2199 */2200 async getTotalPieces(collectionId: number): Promise<bigint> {2201 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2202 }22032204 /**2205 * Set, change, or remove approved address to transfer tokens.2206 *2207 * @param signer keyring of signer2208 * @param collectionId ID of collection2209 * @param toAddressObj address to be approved2210 * @param amount amount of tokens to be approved2211 * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2212 * @returns ```true``` if extrinsic success, otherwise ```false```2213 */2214 approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2215 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2216 }22172218 /**2219 * Get amount of fungible tokens approved to transfer2220 * @param collectionId ID of collection2221 * @param fromAddressObj owner of tokens2222 * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2223 * @returns number of tokens approved for the transfer2224 */2225 getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2226 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2227 }2228}222922302231class ChainGroup extends HelperGroup<ChainHelperBase> {2232 /**2233 * Get system properties of a chain2234 * @example getChainProperties();2235 * @returns ss58Format, token decimals, and token symbol2236 */2237 getChainProperties(): IChainProperties {2238 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2239 return {2240 ss58Format: properties.ss58Format.toJSON(),2241 tokenDecimals: properties.tokenDecimals.toJSON(),2242 tokenSymbol: properties.tokenSymbol.toJSON(),2243 };2244 }22452246 /**2247 * Get chain header2248 * @example getLatestBlockNumber();2249 * @returns the number of the last block2250 */2251 async getLatestBlockNumber(): Promise<number> {2252 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2253 }22542255 /**2256 * Get block hash by block number2257 * @param blockNumber number of block2258 * @example getBlockHashByNumber(12345);2259 * @returns hash of a block2260 */2261 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2262 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2263 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2264 return blockHash;2265 }22662267 // TODO add docs2268 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2269 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2270 if (!blockHash) return null;2271 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2272 }22732274 /**2275 * Get latest relay block2276 * @returns {number} relay block2277 */2278 async getRelayBlockNumber(): Promise<bigint> {2279 const blockNumber = (await this.helper.callRpc('api.query.parachainSystem.validationData')).toJSON().relayParentNumber;2280 return BigInt(blockNumber);2281 }22822283 /**2284 * Get account nonce2285 * @param address substrate address2286 * @example getNonce("5GrwvaEF5zXb26Fz...");2287 * @returns number, account's nonce2288 */2289 async getNonce(address: TSubstrateAccount): Promise<number> {2290 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2291 }2292}22932294class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2295 /**2296 * Get substrate address balance2297 * @param address substrate address2298 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2299 * @returns amount of tokens on address2300 */2301 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2302 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2303 }23042305 /**2306 * Transfer tokens to substrate address2307 * @param signer keyring of signer2308 * @param address substrate address of a recipient2309 * @param amount amount of tokens to be transfered2310 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2311 * @returns ```true``` if extrinsic success, otherwise ```false```2312 */2313 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2314 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}`*/);23152316 let transfer = {from: null, to: null, amount: 0n} as any;2317 result.result.events.forEach(({event: {data, method, section}}) => {2318 if ((section === 'balances') && (method === 'Transfer')) {2319 transfer = {2320 from: this.helper.address.normalizeSubstrate(data[0]),2321 to: this.helper.address.normalizeSubstrate(data[1]),2322 amount: BigInt(data[2]),2323 };2324 }2325 });2326 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from2327 && this.helper.address.normalizeSubstrate(address) === transfer.to2328 && BigInt(amount) === transfer.amount;2329 return isSuccess;2330 }23312332 /**2333 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2334 * @param address substrate address2335 * @returns2336 */2337 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2338 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2339 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2340 }23412342 async getLocked(address: TSubstrateAccount): Promise<[{id: string, amount: bigint, reason: string}]> {2343 const locks = (await this.helper.callRpc('api.query.balances.locks', [address])).toHuman();2344 return locks.map((lock: any) => {return {id: lock.id, amount: BigInt(lock.amount.replace(/,/g, '')), reasons: lock.reasons};});2345 }2346}23472348class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2349 /**2350 * Get ethereum address balance2351 * @param address ethereum address2352 * @example getEthereum("0x9F0583DbB855d...")2353 * @returns amount of tokens on address2354 */2355 async getEthereum(address: TEthereumAccount): Promise<bigint> {2356 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2357 }23582359 /**2360 * Transfer tokens to address2361 * @param signer keyring of signer2362 * @param address Ethereum address of a recipient2363 * @param amount amount of tokens to be transfered2364 * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2365 * @returns ```true``` if extrinsic success, otherwise ```false```2366 */2367 async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2368 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);23692370 let transfer = {from: null, to: null, amount: 0n} as any;2371 result.result.events.forEach(({event: {data, method, section}}) => {2372 if ((section === 'balances') && (method === 'Transfer')) {2373 transfer = {2374 from: data[0].toString(),2375 to: data[1].toString(),2376 amount: BigInt(data[2]),2377 };2378 }2379 });2380 const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from2381 && address === transfer.to2382 && BigInt(amount) === transfer.amount;2383 return isSuccess;2384 }2385}23862387class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2388 subBalanceGroup: SubstrateBalanceGroup<T>;2389 ethBalanceGroup: EthereumBalanceGroup<T>;23902391 constructor(helper: T) {2392 super(helper);2393 this.subBalanceGroup = new SubstrateBalanceGroup(helper);2394 this.ethBalanceGroup = new EthereumBalanceGroup(helper);2395 }23962397 getCollectionCreationPrice(): bigint {2398 return 2n * this.getOneTokenNominal();2399 }2400 /**2401 * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2402 * @example getOneTokenNominal()2403 * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2404 */2405 getOneTokenNominal(): bigint {2406 const chainProperties = this.helper.chain.getChainProperties();2407 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2408 }24092410 /**2411 * Get substrate address balance2412 * @param address substrate address2413 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2414 * @returns amount of tokens on address2415 */2416 getSubstrate(address: TSubstrateAccount): Promise<bigint> {2417 return this.subBalanceGroup.getSubstrate(address);2418 }24192420 /**2421 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2422 * @param address substrate address2423 * @returns2424 */2425 getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2426 return this.subBalanceGroup.getSubstrateFull(address);2427 }24282429 /**2430 * Get locked balances2431 * @param address substrate address2432 * @returns locked balances with reason via api.query.balances.locks2433 */2434 getLocked(address: TSubstrateAccount) {2435 return this.subBalanceGroup.getLocked(address);2436 }24372438 /**2439 * Get ethereum address balance2440 * @param address ethereum address2441 * @example getEthereum("0x9F0583DbB855d...")2442 * @returns amount of tokens on address2443 */2444 getEthereum(address: TEthereumAccount): Promise<bigint> {2445 return this.ethBalanceGroup.getEthereum(address);2446 }24472448 /**2449 * Transfer tokens to substrate address2450 * @param signer keyring of signer2451 * @param address substrate address of a recipient2452 * @param amount amount of tokens to be transfered2453 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2454 * @returns ```true``` if extrinsic success, otherwise ```false```2455 */2456 transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2457 return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2458 }24592460 async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2461 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);24622463 let transfer = {from: null, to: null, amount: 0n} as any;2464 result.result.events.forEach(({event: {data, method, section}}) => {2465 if ((section === 'balances') && (method === 'Transfer')) {2466 transfer = {2467 from: this.helper.address.normalizeSubstrate(data[0]),2468 to: this.helper.address.normalizeSubstrate(data[1]),2469 amount: BigInt(data[2]),2470 };2471 }2472 });2473 let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2474 isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2475 isSuccess = isSuccess && BigInt(amount) === transfer.amount;2476 return isSuccess;2477 }24782479 /**2480 * Transfer tokens with the unlock period2481 * @param signer signers Keyring2482 * @param address Substrate address of recipient2483 * @param schedule Schedule params2484 * @example vestedTransfer(signer, recepient.address, 20000, 100, 10, 50 * nominal); // total amount of vested tokens will be 100 * 50 = 50002485 */2486 async vestedTransfer(signer: TSigner, address: TSubstrateAccount, schedule: {start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}): Promise<void> {2487 const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.vestedTransfer', [address, schedule]);2488 const event = result.result.events2489 .find(e => e.event.section === 'vesting' &&2490 e.event.method === 'VestingScheduleAdded' &&2491 e.event.data[0].toHuman() === signer.address);2492 if (!event) throw Error('Cannot find transfer in events');2493 }24942495 /**2496 * Get schedule for recepient of vested transfer2497 * @param address Substrate address of recipient2498 * @returns2499 */2500 async getVestingSchedules(address: TSubstrateAccount): Promise<{start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}[]> {2501 const schedule = (await this.helper.callRpc('api.query.vesting.vestingSchedules', [address])).toJSON();2502 return schedule.map((schedule: any) => {2503 return {2504 start: BigInt(schedule.start),2505 period: BigInt(schedule.period),2506 periodCount: BigInt(schedule.periodCount),2507 perPeriod: BigInt(schedule.perPeriod),2508 };2509 });2510 }25112512 /**2513 * Claim vested tokens2514 * @param signer signers Keyring2515 */2516 async claim(signer: TSigner) {2517 const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.claim', []);2518 const event = result.result.events2519 .find(e => e.event.section === 'vesting' &&2520 e.event.method === 'Claimed' &&2521 e.event.data[0].toHuman() === signer.address);2522 if (!event) throw Error('Cannot find claim in events');2523 }2524}25252526class AddressGroup extends HelperGroup<ChainHelperBase> {2527 /**2528 * Normalizes the address to the specified ss58 format, by default ```42```.2529 * @param address substrate address2530 * @param ss58Format format for address conversion, by default ```42```2531 * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2532 * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2533 */2534 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2535 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2536 }25372538 /**2539 * Get address in the connected chain format2540 * @param address substrate address2541 * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2542 * @returns address in chain format2543 */2544 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2545 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2546 }25472548 /**2549 * Get substrate mirror of an ethereum address2550 * @param ethAddress ethereum address2551 * @param toChainFormat false for normalized account2552 * @example ethToSubstrate('0x9F0583DbB855d...')2553 * @returns substrate mirror of a provided ethereum address2554 */2555 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2556 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2557 }25582559 /**2560 * Get ethereum mirror of a substrate address2561 * @param subAddress substrate account2562 * @example substrateToEth("5DnSF6RRjwteE3BrC...")2563 * @returns ethereum mirror of a provided substrate address2564 */2565 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2566 return CrossAccountId.translateSubToEth(subAddress);2567 }25682569 /**2570 * Encode key to substrate address2571 * @param key key for encoding address2572 * @param ss58Format prefix for encoding to the address of the corresponding network2573 * @returns encoded substrate address2574 */2575 encodeSubstrateAddress (key: Uint8Array | string | bigint, ss58Format = 42): string {2576 const u8a :Uint8Array = typeof key === 'string'2577 ? hexToU8a(key)2578 : typeof key === 'bigint'2579 ? hexToU8a(key.toString(16))2580 : key;25812582 if (ss58Format < 0 || ss58Format > 16383 || [46, 47].includes(ss58Format)) {2583 throw new Error(`ss58Format is not valid, received ${typeofss58Format} "${ss58Format}"`);2584 }25852586 const allowedDecodedLengths = [1, 2, 4, 8, 32, 33];2587 if (!allowedDecodedLengths.includes(u8a.length)) {2588 throw new Error(`key length is not valid, received ${u8a.length}, valid values are ${allowedDecodedLengths.join(', ')}`);2589 }25902591 const u8aPrefix = ss58Format < 642592 ? new Uint8Array([ss58Format])2593 : new Uint8Array([2594 ((ss58Format & 0xfc) >> 2) | 0x40,2595 (ss58Format >> 8) | ((ss58Format & 0x03) << 6),2596 ]);25972598 const input = u8aConcat(u8aPrefix, u8a);25992600 return base58Encode(u8aConcat(2601 input,2602 blake2AsU8a(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1),2603 ));2604 }26052606 /**2607 * Restore substrate address from bigint representation2608 * @param number decimal representation of substrate address2609 * @returns substrate address2610 */2611 restoreCrossAccountFromBigInt(number: bigint): TSubstrateAccount {2612 if (this.helper.api === null) {2613 throw 'Not connected';2614 }2615 const res = this.helper.api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();2616 if (res === undefined || res === null) {2617 throw 'Restore address error';2618 }2619 return res.toString();2620 }26212622 /**2623 * Convert etherium cross account id to substrate cross account id2624 * @param ethCrossAccount etherium cross account2625 * @returns substrate cross account id2626 */2627 convertCrossAccountFromEthCrossAccount(ethCrossAccount: IEthCrossAccountId): ICrossAccountId {2628 if (ethCrossAccount.sub === '0') {2629 return {Ethereum: ethCrossAccount.eth.toLocaleLowerCase()};2630 }26312632 const ss58 = this.restoreCrossAccountFromBigInt(BigInt(ethCrossAccount.sub));2633 return {Substrate: ss58};2634 }26352636 paraSiblingSovereignAccount(paraid: number) {2637 // We are getting a *sibling* parachain sovereign account,2638 // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c2639 const siblingPrefix = '0x7369626c';26402641 const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2642 const suffix = '000000000000000000000000000000000000000000000000';26432644 return siblingPrefix + encodedParaId + suffix;2645 }2646}26472648class StakingGroup extends HelperGroup<UniqueHelper> {2649 /**2650 * Stake tokens for App Promotion2651 * @param signer keyring of signer2652 * @param amountToStake amount of tokens to stake2653 * @param label extra label for log2654 * @returns2655 */2656 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2657 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2658 const _stakeResult = await this.helper.executeExtrinsic(2659 signer, 'api.tx.appPromotion.stake',2660 [amountToStake], true,2661 );2662 // TODO extract info from stakeResult2663 return true;2664 }26652666 /**2667 * Unstake all staked tokens2668 * @param signer keyring of signer2669 * @param amountToUnstake amount of tokens to unstake2670 * @param label extra label for log2671 * @returns block hash where unstake happened2672 */2673 async unstakeAll(signer: TSigner, label?: string): Promise<string> {2674 if(typeof label === 'undefined') label = `${signer.address}`;2675 const unstakeResult = await this.helper.executeExtrinsic(2676 signer, 'api.tx.appPromotion.unstakeAll',2677 [], true,2678 );2679 return unstakeResult.blockHash;2680 }26812682 /**2683 * Unstake the part of a staked tokens2684 * @param signer keyring of signer2685 * @param amount amount of tokens to unstake2686 * @param label extra label for log2687 * @returns block hash where unstake happened2688 */2689 async unstakePartial(signer: TSigner, amount: bigint, label?: string): Promise<string> {2690 if(typeof label === 'undefined') label = `${signer.address}`;2691 const unstakeResult = await this.helper.executeExtrinsic(2692 signer, 'api.tx.appPromotion.unstakePartial',2693 [amount], true,2694 );2695 return unstakeResult.blockHash;2696 }26972698 /**2699 * Get total number of active stakes2700 * @param address substrate address2701 * @returns {number}2702 */2703 async getStakesNumber(address: ICrossAccountId): Promise<number> {2704 if (address.Ethereum) throw Error('only substrate address');2705 return (await this.helper.callRpc('api.query.appPromotion.stakesPerAccount', [address.Substrate])).toNumber();2706 }27072708 /**2709 * Get total staked amount for address2710 * @param address substrate or ethereum address2711 * @returns total staked amount2712 */2713 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2714 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2715 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2716 }27172718 /**2719 * Get total staked per block2720 * @param address substrate or ethereum address2721 * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2722 */2723 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2724 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2725 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2726 return {2727 block: block.toBigInt(),2728 amount: amount.toBigInt(),2729 };2730 });2731 }27322733 /**2734 * Get total pending unstake amount for address2735 * @param address substrate or ethereum address2736 * @returns total pending unstake amount2737 */2738 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2739 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2740 }27412742 /**2743 * Get pending unstake amount per block for address2744 * @param address substrate or ethereum address2745 * @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 block2746 */2747 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2748 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2749 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2750 return {2751 block: block.toBigInt(),2752 amount: amount.toBigInt(),2753 };2754 });2755 return result;2756 }2757}27582759class SchedulerGroup extends HelperGroup<UniqueHelper> {2760 constructor(helper: UniqueHelper) {2761 super(helper);2762 }27632764 cancelScheduled(signer: TSigner, scheduledId: string) {2765 return this.helper.executeExtrinsic(2766 signer,2767 'api.tx.scheduler.cancelNamed',2768 [scheduledId],2769 true,2770 );2771 }27722773 changePriority(signer: TSigner, scheduledId: string, priority: number) {2774 return this.helper.executeExtrinsic(2775 signer,2776 'api.tx.scheduler.changeNamedPriority',2777 [scheduledId, priority],2778 true,2779 );2780 }27812782 scheduleAt<T extends UniqueHelper>(2783 executionBlockNumber: number,2784 options: ISchedulerOptions = {},2785 ) {2786 return this.schedule<T>('schedule', executionBlockNumber, options);2787 }27882789 scheduleAfter<T extends UniqueHelper>(2790 blocksBeforeExecution: number,2791 options: ISchedulerOptions = {},2792 ) {2793 return this.schedule<T>('scheduleAfter', blocksBeforeExecution, options);2794 }27952796 schedule<T extends UniqueHelper>(2797 scheduleFn: 'schedule' | 'scheduleAfter',2798 blocksNum: number,2799 options: ISchedulerOptions = {},2800 ) {2801 // eslint-disable-next-line @typescript-eslint/naming-convention2802 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2803 return this.helper.clone(ScheduledHelperType, {2804 scheduleFn,2805 blocksNum,2806 options,2807 }) as T;2808 }2809}28102811class CollatorSelectionGroup extends HelperGroup<UniqueHelper> {2812 //todo:collator documentation2813 addInvulnerable(signer: TSigner, address: string) {2814 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.addInvulnerable', [address]);2815 }28162817 removeInvulnerable(signer: TSigner, address: string) {2818 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.removeInvulnerable', [address]);2819 }28202821 async getInvulnerables(): Promise<string[]> {2822 return (await this.helper.callRpc('api.query.collatorSelection.invulnerables')).map((x: any) => x.toHuman());2823 }28242825 /** and also total max invulnerables */2826 maxCollators(): number {2827 return (this.helper.getApi().consts.configuration.defaultCollatorSelectionMaxCollators.toJSON() as number);2828 }28292830 async getDesiredCollators(): Promise<number> {2831 return (await this.helper.callRpc('api.query.configuration.collatorSelectionDesiredCollatorsOverride')).toNumber();2832 }28332834 setLicenseBond(signer: TSigner, amount: bigint) {2835 return this.helper.executeExtrinsic(signer, 'api.tx.configuration.setCollatorSelectionLicenseBond', [amount]);2836 }28372838 async getLicenseBond(): Promise<bigint> {2839 return (await this.helper.callRpc('api.query.configuration.collatorSelectionLicenseBondOverride')).toBigInt();2840 }28412842 obtainLicense(signer: TSigner) {2843 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.getLicense', []);2844 }28452846 releaseLicense(signer: TSigner) {2847 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.releaseLicense', []);2848 }28492850 forceReleaseLicense(signer: TSigner, released: string) {2851 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.forceReleaseLicense', [released]);2852 }28532854 async hasLicense(address: string): Promise<bigint> {2855 return (await this.helper.callRpc('api.query.collatorSelection.licenseDepositOf', [address])).toBigInt();2856 }28572858 onboard(signer: TSigner) {2859 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.onboard', []);2860 }28612862 offboard(signer: TSigner) {2863 return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.offboard', []);2864 }28652866 async getCandidates(): Promise<string[]> {2867 return (await this.helper.callRpc('api.query.collatorSelection.candidates')).map((x: any) => x.toHuman());2868 }2869}28702871class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2872 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2873 await this.helper.executeExtrinsic(2874 signer,2875 'api.tx.foreignAssets.registerForeignAsset',2876 [ownerAddress, location, metadata],2877 true,2878 );2879 }28802881 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2882 await this.helper.executeExtrinsic(2883 signer,2884 'api.tx.foreignAssets.updateForeignAsset',2885 [foreignAssetId, location, metadata],2886 true,2887 );2888 }2889}28902891class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2892 palletName: string;28932894 constructor(helper: T, palletName: string) {2895 super(helper);28962897 this.palletName = palletName;2898 }28992900 async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: any) {2901 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, weightLimit], true);2902 }29032904 async teleportAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number) {2905 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.teleportAssets`, [destination, beneficiary, assets, feeAssetItem], true);2906 }29072908 async teleportNativeAsset(signer: TSigner, destinationParaId: number, targetAccount: Uint8Array, amount: bigint) {2909 const destination = {2910 V1: {2911 parents: 0,2912 interior: {2913 X1: {2914 Parachain: destinationParaId,2915 },2916 },2917 },2918 };29192920 const beneficiary = {2921 V1: {2922 parents: 0,2923 interior: {2924 X1: {2925 AccountId32: {2926 network: 'Any',2927 id: targetAccount,2928 },2929 },2930 },2931 },2932 };29332934 const assets = {2935 V1: [2936 {2937 id: {2938 Concrete: {2939 parents: 0,2940 interior: 'Here',2941 },2942 },2943 fun: {2944 Fungible: amount,2945 },2946 },2947 ],2948 };29492950 const feeAssetItem = 0;29512952 await this.teleportAssets(signer, destination, beneficiary, assets, feeAssetItem);2953 }2954}29552956class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2957 async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: any) {2958 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);2959 }29602961 async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: any) {2962 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);2963 }29642965 async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: any) {2966 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);2967 }2968}29692970class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2971 async accounts(address: string, currencyId: any) {2972 const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;2973 return BigInt(free);2974 }2975}29762977class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {2978 async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {2979 await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);2980 }29812982 async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {2983 await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);2984 }29852986 async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {2987 await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);2988 }29892990 async account(assetId: string | number, address: string) {2991 const accountAsset = (2992 await this.helper.callRpc('api.query.assets.account', [assetId, address])2993 ).toJSON()! as any;29942995 if (accountAsset !== null) {2996 return BigInt(accountAsset['balance']);2997 } else {2998 return null;2999 }3000 }3001}30023003class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {3004 async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {3005 await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);3006 }3007}30083009class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {3010 makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {3011 const apiPrefix = 'api.tx.assetManager.';30123013 const registerTx = this.helper.constructApiCall(3014 apiPrefix + 'registerForeignAsset',3015 [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],3016 );30173018 const setUnitsTx = this.helper.constructApiCall(3019 apiPrefix + 'setAssetUnitsPerSecond',3020 [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],3021 );30223023 const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);3024 const encodedProposal = batchCall?.method.toHex() || '';3025 return encodedProposal;3026 }30273028 async assetTypeId(location: any) {3029 return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);3030 }3031}30323033class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {3034 notePreimagePallet: string;30353036 constructor(helper: MoonbeamHelper, options: {[key: string]: any} = {}) {3037 super(helper);3038 this.notePreimagePallet = options.notePreimagePallet;3039 }30403041 async notePreimage(signer: TSigner, encodedProposal: string) {3042 await this.helper.executeExtrinsic(signer, `api.tx.${this.notePreimagePallet}.notePreimage`, [encodedProposal], true);3043 }30443045 externalProposeMajority(proposal: any) {3046 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposal]);3047 }30483049 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {3050 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);3051 }30523053 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {3054 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);3055 }3056}30573058class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {3059 collective: string;30603061 constructor(helper: MoonbeamHelper, collective: string) {3062 super(helper);30633064 this.collective = collective;3065 }30663067 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {3068 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);3069 }30703071 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {3072 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);3073 }30743075 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: any, lengthBound: number) {3076 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);3077 }30783079 async proposalCount() {3080 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));3081 }3082}30833084export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;3085export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;30863087export class UniqueHelper extends ChainHelperBase {3088 balance: BalanceGroup<UniqueHelper>;3089 collection: CollectionGroup;3090 nft: NFTGroup;3091 rft: RFTGroup;3092 ft: FTGroup;3093 staking: StakingGroup;3094 scheduler: SchedulerGroup;3095 collatorSelection: CollatorSelectionGroup;3096 foreignAssets: ForeignAssetsGroup;3097 xcm: XcmGroup<UniqueHelper>;3098 xTokens: XTokensGroup<UniqueHelper>;3099 tokens: TokensGroup<UniqueHelper>;31003101 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3102 super(logger, options.helperBase ?? UniqueHelper);31033104 this.balance = new BalanceGroup(this);3105 this.collection = new CollectionGroup(this);3106 this.nft = new NFTGroup(this);3107 this.rft = new RFTGroup(this);3108 this.ft = new FTGroup(this);3109 this.staking = new StakingGroup(this);3110 this.scheduler = new SchedulerGroup(this);3111 this.collatorSelection = new CollatorSelectionGroup(this);3112 this.foreignAssets = new ForeignAssetsGroup(this);3113 this.xcm = new XcmGroup(this, 'polkadotXcm');3114 this.xTokens = new XTokensGroup(this);3115 this.tokens = new TokensGroup(this);3116 }31173118 getSudo<T extends UniqueHelper>() {3119 // eslint-disable-next-line @typescript-eslint/naming-convention3120 const SudoHelperType = SudoHelper(this.helperBase);3121 return this.clone(SudoHelperType) as T;3122 }3123}31243125export class XcmChainHelper extends ChainHelperBase {3126 async connect(wsEndpoint: string, _listeners?: any): Promise<void> {3127 const wsProvider = new WsProvider(wsEndpoint);3128 this.api = new ApiPromise({3129 provider: wsProvider,3130 });3131 await this.api.isReadyOrError;3132 this.network = await UniqueHelper.detectNetwork(this.api);3133 }3134}31353136export class RelayHelper extends XcmChainHelper {3137 balance: SubstrateBalanceGroup<RelayHelper>;3138 xcm: XcmGroup<RelayHelper>;31393140 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3141 super(logger, options.helperBase ?? RelayHelper);31423143 this.balance = new SubstrateBalanceGroup(this);3144 this.xcm = new XcmGroup(this, 'xcmPallet');3145 }3146}31473148export class WestmintHelper extends XcmChainHelper {3149 balance: SubstrateBalanceGroup<WestmintHelper>;3150 xcm: XcmGroup<WestmintHelper>;3151 assets: AssetsGroup<WestmintHelper>;3152 xTokens: XTokensGroup<WestmintHelper>;31533154 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3155 super(logger, options.helperBase ?? WestmintHelper);31563157 this.balance = new SubstrateBalanceGroup(this);3158 this.xcm = new XcmGroup(this, 'polkadotXcm');3159 this.assets = new AssetsGroup(this);3160 this.xTokens = new XTokensGroup(this);3161 }3162}31633164export class MoonbeamHelper extends XcmChainHelper {3165 balance: EthereumBalanceGroup<MoonbeamHelper>;3166 assetManager: MoonbeamAssetManagerGroup;3167 assets: AssetsGroup<MoonbeamHelper>;3168 xTokens: XTokensGroup<MoonbeamHelper>;3169 democracy: MoonbeamDemocracyGroup;3170 collective: {3171 council: MoonbeamCollectiveGroup,3172 techCommittee: MoonbeamCollectiveGroup,3173 };31743175 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3176 super(logger, options.helperBase ?? MoonbeamHelper);31773178 this.balance = new EthereumBalanceGroup(this);3179 this.assetManager = new MoonbeamAssetManagerGroup(this);3180 this.assets = new AssetsGroup(this);3181 this.xTokens = new XTokensGroup(this);3182 this.democracy = new MoonbeamDemocracyGroup(this, options);3183 this.collective = {3184 council: new MoonbeamCollectiveGroup(this, 'councilCollective'),3185 techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),3186 };3187 }3188}31893190export class AcalaHelper extends XcmChainHelper {3191 balance: SubstrateBalanceGroup<AcalaHelper>;3192 assetRegistry: AcalaAssetRegistryGroup;3193 xTokens: XTokensGroup<AcalaHelper>;3194 tokens: TokensGroup<AcalaHelper>;31953196 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3197 super(logger, options.helperBase ?? AcalaHelper);31983199 this.balance = new SubstrateBalanceGroup(this);3200 this.assetRegistry = new AcalaAssetRegistryGroup(this);3201 this.xTokens = new XTokensGroup(this);3202 this.tokens = new TokensGroup(this);3203 }32043205 getSudo<T extends AcalaHelper>() {3206 // eslint-disable-next-line @typescript-eslint/naming-convention3207 const SudoHelperType = SudoHelper(this.helperBase);3208 return this.clone(SudoHelperType) as T;3209 }3210}32113212// eslint-disable-next-line @typescript-eslint/naming-convention3213function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {3214 return class extends Base {3215 scheduleFn: 'schedule' | 'scheduleAfter';3216 blocksNum: number;3217 options: ISchedulerOptions;32183219 constructor(...args: any[]) {3220 const logger = args[0] as ILogger;3221 const options = args[1] as {3222 scheduleFn: 'schedule' | 'scheduleAfter',3223 blocksNum: number,3224 options: ISchedulerOptions3225 };32263227 super(logger);32283229 this.scheduleFn = options.scheduleFn;3230 this.blocksNum = options.blocksNum;3231 this.options = options.options;3232 }32333234 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {3235 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);32363237 const mandatorySchedArgs = [3238 this.blocksNum,3239 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,3240 this.options.priority ?? null,3241 scheduledTx,3242 ];32433244 let schedArgs;3245 let scheduleFn;32463247 if (this.options.scheduledId) {3248 schedArgs = [this.options.scheduledId!, ...mandatorySchedArgs];32493250 if (this.scheduleFn == 'schedule') {3251 scheduleFn = 'scheduleNamed';3252 } else if (this.scheduleFn == 'scheduleAfter') {3253 scheduleFn = 'scheduleNamedAfter';3254 }3255 } else {3256 schedArgs = mandatorySchedArgs;3257 scheduleFn = this.scheduleFn;3258 }32593260 const extrinsic = 'api.tx.scheduler.' + scheduleFn;32613262 return super.executeExtrinsic(3263 sender,3264 extrinsic,3265 schedArgs,3266 expectSuccess,3267 );3268 }3269 };3270}32713272// eslint-disable-next-line @typescript-eslint/naming-convention3273function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {3274 return class extends Base {3275 constructor(...args: any[]) {3276 super(...args);3277 }32783279 async executeExtrinsic(3280 sender: IKeyringPair,3281 extrinsic: string,3282 params: any[],3283 expectSuccess?: boolean,3284 options: Partial<SignerOptions>|null = null,3285 ): Promise<ITransactionResult> {3286 const call = this.constructApiCall(extrinsic, params);3287 const result = await super.executeExtrinsic(3288 sender,3289 'api.tx.sudo.sudo',3290 [call],3291 expectSuccess,3292 options,3293 );32943295 if (result.status === 'Fail') return result;32963297 const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;3298 if (data.isErr) {3299 if (data.asErr.isModule) {3300 const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;3301 const metaError = super.getApi()?.registry.findMetaError(error);3302 throw new Error(`${metaError.section}.${metaError.name}`);3303 } else {3304 throw new Error(data.asErr.toHuman());3305 }3306 }3307 return result;3308 }3309 };3310}33113312export class UniqueBaseCollection {3313 helper: UniqueHelper;3314 collectionId: number;33153316 constructor(collectionId: number, uniqueHelper: UniqueHelper) {3317 this.collectionId = collectionId;3318 this.helper = uniqueHelper;3319 }33203321 async getData() {3322 return await this.helper.collection.getData(this.collectionId);3323 }33243325 async getLastTokenId() {3326 return await this.helper.collection.getLastTokenId(this.collectionId);3327 }33283329 async doesTokenExist(tokenId: number) {3330 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);3331 }33323333 async getAdmins() {3334 return await this.helper.collection.getAdmins(this.collectionId);3335 }33363337 async getAllowList() {3338 return await this.helper.collection.getAllowList(this.collectionId);3339 }33403341 async getEffectiveLimits() {3342 return await this.helper.collection.getEffectiveLimits(this.collectionId);3343 }33443345 async getProperties(propertyKeys?: string[] | null) {3346 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);3347 }33483349 async getPropertiesConsumedSpace() {3350 return await this.helper.collection.getPropertiesConsumedSpace(this.collectionId);3351 }33523353 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {3354 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);3355 }33563357 async getOptions() {3358 return await this.helper.collection.getCollectionOptions(this.collectionId);3359 }33603361 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {3362 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);3363 }33643365 async confirmSponsorship(signer: TSigner) {3366 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);3367 }33683369 async removeSponsor(signer: TSigner) {3370 return await this.helper.collection.removeSponsor(signer, this.collectionId);3371 }33723373 async setLimits(signer: TSigner, limits: ICollectionLimits) {3374 return await this.helper.collection.setLimits(signer, this.collectionId, limits);3375 }33763377 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {3378 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);3379 }33803381 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3382 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);3383 }33843385 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {3386 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);3387 }33883389 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {3390 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);3391 }33923393 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3394 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);3395 }33963397 async setProperties(signer: TSigner, properties: IProperty[]) {3398 return await this.helper.collection.setProperties(signer, this.collectionId, properties);3399 }34003401 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3402 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);3403 }34043405 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {3406 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);3407 }34083409 async enableNesting(signer: TSigner, permissions: INestingPermissions) {3410 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);3411 }34123413 async disableNesting(signer: TSigner) {3414 return await this.helper.collection.disableNesting(signer, this.collectionId);3415 }34163417 async burn(signer: TSigner) {3418 return await this.helper.collection.burn(signer, this.collectionId);3419 }34203421 scheduleAt<T extends UniqueHelper>(3422 executionBlockNumber: number,3423 options: ISchedulerOptions = {},3424 ) {3425 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3426 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3427 }34283429 scheduleAfter<T extends UniqueHelper>(3430 blocksBeforeExecution: number,3431 options: ISchedulerOptions = {},3432 ) {3433 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3434 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3435 }34363437 getSudo<T extends UniqueHelper>() {3438 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());3439 }3440}344134423443export class UniqueNFTCollection extends UniqueBaseCollection {3444 getTokenObject(tokenId: number) {3445 return new UniqueNFToken(tokenId, this);3446 }34473448 async getTokensByAddress(addressObj: ICrossAccountId) {3449 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);3450 }34513452 async getToken(tokenId: number, blockHashAt?: string) {3453 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);3454 }34553456 async getTokenOwner(tokenId: number, blockHashAt?: string) {3457 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3458 }34593460 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3461 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3462 }34633464 async getTokenChildren(tokenId: number, blockHashAt?: string) {3465 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);3466 }34673468 async getPropertyPermissions(propertyKeys: string[] | null = null) {3469 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);3470 }34713472 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3473 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3474 }34753476 async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3477 const api = this.helper.getApi();3478 const props = (await api.query.nonfungible.tokenProperties(this.collectionId, tokenId)).toJSON();34793480 return (props! as any).consumedSpace;3481 }34823483 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {3484 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);3485 }34863487 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3488 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);3489 }34903491 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {3492 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);3493 }34943495 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {3496 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);3497 }34983499 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3500 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});3501 }35023503 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {3504 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);3505 }35063507 async burnToken(signer: TSigner, tokenId: number) {3508 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);3509 }35103511 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {3512 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);3513 }35143515 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3516 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);3517 }35183519 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3520 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3521 }35223523 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3524 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3525 }35263527 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3528 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3529 }35303531 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3532 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3533 }35343535 scheduleAt<T extends UniqueHelper>(3536 executionBlockNumber: number,3537 options: ISchedulerOptions = {},3538 ) {3539 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3540 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3541 }35423543 scheduleAfter<T extends UniqueHelper>(3544 blocksBeforeExecution: number,3545 options: ISchedulerOptions = {},3546 ) {3547 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3548 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3549 }35503551 getSudo<T extends UniqueHelper>() {3552 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());3553 }3554}355535563557export class UniqueRFTCollection extends UniqueBaseCollection {3558 getTokenObject(tokenId: number) {3559 return new UniqueRFToken(tokenId, this);3560 }35613562 async getToken(tokenId: number, blockHashAt?: string) {3563 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);3564 }35653566 async getTokenOwner(tokenId: number, blockHashAt?: string) {3567 return await this.helper.rft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3568 }35693570 async getTokensByAddress(addressObj: ICrossAccountId) {3571 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);3572 }35733574 async getTop10TokenOwners(tokenId: number) {3575 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);3576 }35773578 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3579 return await this.helper.rft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3580 }35813582 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {3583 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3584 }35853586 async getTokenTotalPieces(tokenId: number) {3587 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3588 }35893590 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3591 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3592 }35933594 async getPropertyPermissions(propertyKeys: string[] | null = null) {3595 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3596 }35973598 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3599 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3600 }36013602 async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3603 const api = this.helper.getApi();3604 const props = (await api.query.refungible.tokenProperties(this.collectionId, tokenId)).toJSON();36053606 return (props! as any).consumedSpace;3607 }36083609 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3610 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3611 }36123613 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3614 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3615 }36163617 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3618 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3619 }36203621 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3622 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3623 }36243625 async mintToken(signer: TSigner, pieces = 1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3626 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3627 }36283629 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3630 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3631 }36323633 async burnToken(signer: TSigner, tokenId: number, amount=1n) {3634 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3635 }36363637 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {3638 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3639 }36403641 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3642 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3643 }36443645 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3646 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3647 }36483649 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3650 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3651 }36523653 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3654 return await this.helper.rft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3655 }36563657 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3658 return await this.helper.rft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3659 }36603661 scheduleAt<T extends UniqueHelper>(3662 executionBlockNumber: number,3663 options: ISchedulerOptions = {},3664 ) {3665 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3666 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3667 }36683669 scheduleAfter<T extends UniqueHelper>(3670 blocksBeforeExecution: number,3671 options: ISchedulerOptions = {},3672 ) {3673 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3674 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3675 }36763677 getSudo<T extends UniqueHelper>() {3678 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3679 }3680}368136823683export class UniqueFTCollection extends UniqueBaseCollection {3684 async getBalance(addressObj: ICrossAccountId) {3685 return await this.helper.ft.getBalance(this.collectionId, addressObj);3686 }36873688 async getTotalPieces() {3689 return await this.helper.ft.getTotalPieces(this.collectionId);3690 }36913692 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3693 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3694 }36953696 async getTop10Owners() {3697 return await this.helper.ft.getTop10Owners(this.collectionId);3698 }36993700 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3701 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3702 }37033704 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3705 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3706 }37073708 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3709 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3710 }37113712 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3713 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3714 }37153716 async burnTokens(signer: TSigner, amount=1n) {3717 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3718 }37193720 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3721 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3722 }37233724 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3725 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3726 }37273728 scheduleAt<T extends UniqueHelper>(3729 executionBlockNumber: number,3730 options: ISchedulerOptions = {},3731 ) {3732 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3733 return new UniqueFTCollection(this.collectionId, scheduledHelper);3734 }37353736 scheduleAfter<T extends UniqueHelper>(3737 blocksBeforeExecution: number,3738 options: ISchedulerOptions = {},3739 ) {3740 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3741 return new UniqueFTCollection(this.collectionId, scheduledHelper);3742 }37433744 getSudo<T extends UniqueHelper>() {3745 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3746 }3747}374837493750export class UniqueBaseToken {3751 collection: UniqueNFTCollection | UniqueRFTCollection;3752 collectionId: number;3753 tokenId: number;37543755 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3756 this.collection = collection;3757 this.collectionId = collection.collectionId;3758 this.tokenId = tokenId;3759 }37603761 async getNextSponsored(addressObj: ICrossAccountId) {3762 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3763 }37643765 async getProperties(propertyKeys?: string[] | null) {3766 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3767 }37683769 async getTokenPropertiesConsumedSpace() {3770 return await this.collection.getTokenPropertiesConsumedSpace(this.tokenId);3771 }37723773 async setProperties(signer: TSigner, properties: IProperty[]) {3774 return await this.collection.setTokenProperties(signer, this.tokenId, properties);3775 }37763777 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3778 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3779 }37803781 async doesExist() {3782 return await this.collection.doesTokenExist(this.tokenId);3783 }37843785 nestingAccount() {3786 return this.collection.helper.util.getTokenAccount(this);3787 }37883789 scheduleAt<T extends UniqueHelper>(3790 executionBlockNumber: number,3791 options: ISchedulerOptions = {},3792 ) {3793 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3794 return new UniqueBaseToken(this.tokenId, scheduledCollection);3795 }37963797 scheduleAfter<T extends UniqueHelper>(3798 blocksBeforeExecution: number,3799 options: ISchedulerOptions = {},3800 ) {3801 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3802 return new UniqueBaseToken(this.tokenId, scheduledCollection);3803 }38043805 getSudo<T extends UniqueHelper>() {3806 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3807 }3808}380938103811export class UniqueNFToken extends UniqueBaseToken {3812 collection: UniqueNFTCollection;38133814 constructor(tokenId: number, collection: UniqueNFTCollection) {3815 super(tokenId, collection);3816 this.collection = collection;3817 }38183819 async getData(blockHashAt?: string) {3820 return await this.collection.getToken(this.tokenId, blockHashAt);3821 }38223823 async getOwner(blockHashAt?: string) {3824 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3825 }38263827 async getTopmostOwner(blockHashAt?: string) {3828 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3829 }38303831 async getChildren(blockHashAt?: string) {3832 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3833 }38343835 async nest(signer: TSigner, toTokenObj: IToken) {3836 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3837 }38383839 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3840 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3841 }38423843 async transfer(signer: TSigner, addressObj: ICrossAccountId) {3844 return await this.collection.transferToken(signer, this.tokenId, addressObj);3845 }38463847 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3848 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3849 }38503851 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3852 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3853 }38543855 async isApproved(toAddressObj: ICrossAccountId) {3856 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3857 }38583859 async burn(signer: TSigner) {3860 return await this.collection.burnToken(signer, this.tokenId);3861 }38623863 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3864 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3865 }38663867 scheduleAt<T extends UniqueHelper>(3868 executionBlockNumber: number,3869 options: ISchedulerOptions = {},3870 ) {3871 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3872 return new UniqueNFToken(this.tokenId, scheduledCollection);3873 }38743875 scheduleAfter<T extends UniqueHelper>(3876 blocksBeforeExecution: number,3877 options: ISchedulerOptions = {},3878 ) {3879 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3880 return new UniqueNFToken(this.tokenId, scheduledCollection);3881 }38823883 getSudo<T extends UniqueHelper>() {3884 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3885 }3886}38873888export class UniqueRFToken extends UniqueBaseToken {3889 collection: UniqueRFTCollection;38903891 constructor(tokenId: number, collection: UniqueRFTCollection) {3892 super(tokenId, collection);3893 this.collection = collection;3894 }38953896 async getData(blockHashAt?: string) {3897 return await this.collection.getToken(this.tokenId, blockHashAt);3898 }38993900 async getOwner(blockHashAt?: string) {3901 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3902 }39033904 async getTop10Owners() {3905 return await this.collection.getTop10TokenOwners(this.tokenId);3906 }39073908 async getTopmostOwner(blockHashAt?: string) {3909 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3910 }39113912 async nest(signer: TSigner, toTokenObj: IToken) {3913 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3914 }39153916 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3917 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3918 }39193920 async getBalance(addressObj: ICrossAccountId) {3921 return await this.collection.getTokenBalance(this.tokenId, addressObj);3922 }39233924 async getTotalPieces() {3925 return await this.collection.getTokenTotalPieces(this.tokenId);3926 }39273928 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {3929 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);3930 }39313932 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {3933 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);3934 }39353936 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3937 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);3938 }39393940 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3941 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);3942 }39433944 async repartition(signer: TSigner, amount: bigint) {3945 return await this.collection.repartitionToken(signer, this.tokenId, amount);3946 }39473948 async burn(signer: TSigner, amount=1n) {3949 return await this.collection.burnToken(signer, this.tokenId, amount);3950 }39513952 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3953 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);3954 }39553956 scheduleAt<T extends UniqueHelper>(3957 executionBlockNumber: number,3958 options: ISchedulerOptions = {},3959 ) {3960 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3961 return new UniqueRFToken(this.tokenId, scheduledCollection);3962 }39633964 scheduleAfter<T extends UniqueHelper>(3965 blocksBeforeExecution: number,3966 options: ISchedulerOptions = {},3967 ) {3968 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3969 return new UniqueRFToken(this.tokenId, scheduledCollection);3970 }39713972 getSudo<T extends UniqueHelper>() {3973 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());3974 }3975}