difftreelog
feat enrich playgrounds with xcm capability
in: master
4 files changed
tests/src/util/playgrounds/index.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/index.ts
+++ b/tests/src/util/playgrounds/index.ts
@@ -7,16 +7,18 @@
import {Context} from 'mocha';
import config from '../../config';
import '../../interfaces/augment-api-events';
-import {DevUniqueHelper, SilentLogger, SilentConsole} from './unique.dev';
+import {ChainHelperBase} from './unique';
+import {ILogger} from './types';
+import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper} from './unique.dev';
chai.use(chaiAsPromised);
export const expect = chai.expect;
-export async function usingPlaygrounds(code: (helper: DevUniqueHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>, url: string = config.substrateUrl) {
+async function usingPlaygroundsGeneral<T extends ChainHelperBase>(helperType: new(logger: ILogger) => T, url: string, code: (helper: T, privateKey: (seed: string) => IKeyringPair) => Promise<void>) {
const silentConsole = new SilentConsole();
silentConsole.enable();
- const helper = new DevUniqueHelper(new SilentLogger());
+ const helper = new helperType(new SilentLogger());
try {
await helper.connect(url);
@@ -30,8 +32,33 @@
}
}
-usingPlaygrounds.atUrl = (url: string, code: (helper: DevUniqueHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
- return usingPlaygrounds(code, url);
+export const usingPlaygrounds = (code: (helper: DevUniqueHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>, url: string = config.substrateUrl) => {
+ return usingPlaygroundsGeneral<DevUniqueHelper>(DevUniqueHelper, url, code);
+};
+
+// TODO specific type
+export const usingStatemintPlaygrounds = async (url: string, code: (helper: DevUniqueHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
+ return usingPlaygroundsGeneral<DevUniqueHelper>(DevUniqueHelper, url, code);
+};
+
+export const usingRelayPlaygrounds = async (url: string, code: (helper: DevRelayHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
+ return usingPlaygroundsGeneral<DevRelayHelper>(DevRelayHelper, url, code);
+};
+
+export const usingAcalaPlaygrounds = async (url: string, code: (helper: DevAcalaHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
+ return usingPlaygroundsGeneral<DevAcalaHelper>(DevAcalaHelper, url, code);
+};
+
+export const usingKaruraPlaygrounds = async (url: string, code: (helper: DevKaruraHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
+ return usingPlaygroundsGeneral<DevKaruraHelper>(DevAcalaHelper, url, code);
+};
+
+export const usingMoonbeamPlaygrounds = async (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
+ return usingPlaygroundsGeneral<DevMoonbeamHelper>(DevMoonbeamHelper, url, code);
+};
+
+export const usingMoonriverPlaygrounds = async (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
+ return usingPlaygroundsGeneral<DevMoonriverHelper>(DevMoonriverHelper, url, code);
};
export enum Pallets {
tests/src/util/playgrounds/types.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/types.ts
+++ b/tests/src/util/playgrounds/types.ts
@@ -179,8 +179,41 @@
minimalBalance?: bigint,
}
+export interface MoonbeamAssetInfo {
+ location: any,
+ metadata: {
+ name: string,
+ symbol: string,
+ decimals: number,
+ isFrozen: boolean,
+ minimalBalance: bigint,
+ },
+ existentialDeposit: bigint,
+ isSufficient: boolean,
+ unitsPerSecond: bigint,
+ numAssetsWeightHint: number,
+}
+
+export interface AcalaAssetMetadata {
+ name: string,
+ symbol: string,
+ decimals: number,
+ minimalBalance: bigint,
+}
+
+export interface DemocracyStandardAccountVote {
+ balance: bigint,
+ vote: {
+ aye: boolean,
+ conviction: number,
+ },
+}
+
export type TSubstrateAccount = string;
export type TEthereumAccount = string;
export type TApiAllowedListeners = 'connected' | 'disconnected' | 'error' | 'ready' | 'decorated';
export type TUniqueNetworks = 'opal' | 'quartz' | 'unique';
+export type TSiblingNetworkds = 'moonbeam' | 'moonriver' | 'acala' | 'karura' | 'westmint';
+export type TRelayNetworks = 'rococo' | 'westend';
+export type TNetworks = TUniqueNetworks | TSiblingNetworkds | TRelayNetworks;
export type TSigner = IKeyringPair; // | 'string'
tests/src/util/playgrounds/unique.dev.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -2,10 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
import {mnemonicGenerate} from '@polkadot/util-crypto';
-import {UniqueHelper} from './unique';
-import {ApiPromise, WsProvider} from '@polkadot/api';
+import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper} from './unique';
+import {ApiPromise, Keyring, WsProvider} from '@polkadot/api';
import * as defs from '../../interfaces/definitions';
import {IKeyringPair} from '@polkadot/types/types';
+import {EventRecord} from '@polkadot/types/interfaces';
import {ICrossAccountId} from './types';
export class SilentLogger {
@@ -52,7 +53,6 @@
console.warn = this.consoleWarn;
}
}
-
export class DevUniqueHelper extends UniqueHelper {
/**
@@ -108,6 +108,36 @@
}
}
+export class DevRelayHelper extends RelayHelper {}
+
+export class DevMoonbeamHelper extends MoonbeamHelper {
+ account: MoonbeamAccountGroup;
+ wait: WaitGroup;
+
+ constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {
+ options.helperBase = options.helperBase ?? DevMoonbeamHelper;
+
+ super(logger, options);
+ this.account = new MoonbeamAccountGroup(this);
+ this.wait = new WaitGroup(this);
+ }
+}
+
+export class DevMoonriverHelper extends DevMoonbeamHelper {}
+
+export class DevAcalaHelper extends AcalaHelper {
+ wait: WaitGroup;
+
+ constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {
+ options.helperBase = options.helperBase ?? DevAcalaHelper;
+
+ super(logger, options);
+ this.wait = new WaitGroup(this);
+ }
+}
+
+export class DevKaruraHelper extends DevAcalaHelper {}
+
class ArrangeGroup {
helper: DevUniqueHelper;
@@ -245,10 +275,43 @@
}
}
+class MoonbeamAccountGroup {
+ helper: MoonbeamHelper;
+
+ _alithAccount: IKeyringPair;
+ _baltatharAccount: IKeyringPair;
+ _dorothyAccount: IKeyringPair;
+
+ constructor(helper: MoonbeamHelper) {
+ this.helper = helper;
+
+ const keyring = new Keyring({type: 'ethereum'});
+ const alithPrivateKey = '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133';
+ const baltatharPrivateKey = '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b';
+ const dorothyPrivateKey = '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68';
+
+ this._alithAccount = keyring.addFromUri(alithPrivateKey, undefined, 'ethereum');
+ this._baltatharAccount = keyring.addFromUri(baltatharPrivateKey, undefined, 'ethereum');
+ this._dorothyAccount = keyring.addFromUri(dorothyPrivateKey, undefined, 'ethereum');
+ }
+
+ alithAccount() {
+ return this._alithAccount;
+ }
+
+ baltatharAccount() {
+ return this._baltatharAccount;
+ }
+
+ dorothyAccount() {
+ return this._dorothyAccount;
+ }
+}
+
class WaitGroup {
- helper: DevUniqueHelper;
+ helper: ChainHelperBase;
- constructor(helper: DevUniqueHelper) {
+ constructor(helper: ChainHelperBase) {
this.helper = helper;
}
@@ -296,6 +359,40 @@
});
});
}
+
+ async event(maxBlocksToWait: number, eventSection: string, eventMethod: string) {
+ // eslint-disable-next-line no-async-promise-executor
+ const promise = new Promise<EventRecord | null>(async (resolve) => {
+ const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(async header => {
+ const blockNumber = header.number.toHuman();
+ const blockHash = header.hash;
+ const eventIdStr = `${eventSection}.${eventMethod}`;
+ const waitLimitStr = `wait blocks remaining: ${maxBlocksToWait}`;
+
+ console.log(`[Block #${blockNumber}] Waiting for event \`${eventIdStr}\` (${waitLimitStr})`);
+
+ const apiAt = await this.helper.getApi().at(blockHash);
+ const eventRecords = await apiAt.query.system.events();
+
+ const neededEvent = eventRecords.find(r => {
+ return r.event.section == eventSection && r.event.method == eventMethod;
+ });
+
+ if (neededEvent) {
+ unsubscribe();
+ resolve(neededEvent);
+ } else if (maxBlocksToWait > 0) {
+ maxBlocksToWait--;
+ } else {
+ console.log(`Event \`${eventIdStr}\` is NOT found`);
+
+ unsubscribe();
+ resolve(null);
+ }
+ });
+ });
+ return promise;
+ }
}
class AdminGroup {
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} from '@polkadot/util-crypto';11import {IKeyringPair} from '@polkadot/types/types';12import {IApiListeners, IBlock, IEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, IStakingInfo, ISchedulerOptions, ISubstrateBalance, IToken, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, TUniqueNetworks, IForeignAssetMetadata} from './types';1314export class CrossAccountId implements ICrossAccountId {15 Substrate?: TSubstrateAccount;16 Ethereum?: TEthereumAccount;1718 constructor(account: ICrossAccountId) {19 if (account.Substrate) this.Substrate = account.Substrate;20 if (account.Ethereum) this.Ethereum = account.Ethereum;21 }2223 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {24 switch (domain) {25 case 'Substrate': return new CrossAccountId({Substrate: account.address});26 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();27 }28 }2930 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {31 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});32 }3334 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {35 return encodeAddress(decodeAddress(address), ss58Format);36 }3738 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {39 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});40 }41 42 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {43 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);44 return this;45 }4647 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {48 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));49 }5051 toEthereum(): CrossAccountId {52 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});53 return this;54 }5556 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {57 return evmToAddress(address, ss58Format);58 }5960 toSubstrate(ss58Format?: number): CrossAccountId {61 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});62 return this;63 }64 65 toLowerCase(): CrossAccountId {66 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();67 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();68 return this;69 }70}7172const nesting = {73 toChecksumAddress(address: string): string {74 if (typeof address === 'undefined') return '';7576 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);7778 address = address.toLowerCase().replace(/^0x/i,'');79 const addressHash = keccakAsHex(address).replace(/^0x/i,'');80 const checksumAddress = ['0x'];8182 for (let i = 0; i < address.length; i++) {83 // If ith character is 8 to f then make it uppercase84 if (parseInt(addressHash[i], 16) > 7) {85 checksumAddress.push(address[i].toUpperCase());86 } else {87 checksumAddress.push(address[i]);88 }89 }90 return checksumAddress.join('');91 },92 tokenIdToAddress(collectionId: number, tokenId: number) {93 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8,'0')}${tokenId.toString(16).padStart(8,'0')}`);94 },95};9697class UniqueUtil {98 static transactionStatus = {99 NOT_READY: 'NotReady',100 FAIL: 'Fail',101 SUCCESS: 'Success',102 };103104 static chainLogType = {105 EXTRINSIC: 'extrinsic',106 RPC: 'rpc',107 };108109 static getTokenAccount(token: IToken): CrossAccountId {110 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});111 }112113 static getTokenAddress(token: IToken): string {114 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);115 }116117 static getDefaultLogger(): ILogger {118 return {119 log(msg: any, level = 'INFO') {120 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));121 },122 level: {123 ERROR: 'ERROR',124 WARNING: 'WARNING',125 INFO: 'INFO',126 },127 };128 }129130 static vec2str(arr: string[] | number[]) {131 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');132 }133134 static str2vec(string: string) {135 if (typeof string !== 'string') return string;136 return Array.from(string).map(x => x.charCodeAt(0));137 }138139 static fromSeed(seed: string, ss58Format = 42) {140 const keyring = new Keyring({type: 'sr25519', ss58Format});141 return keyring.addFromUri(seed);142 }143144 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {145 if (creationResult.status !== this.transactionStatus.SUCCESS) {146 throw Error('Unable to create collection!');147 }148149 let collectionId = null;150 creationResult.result.events.forEach(({event: {data, method, section}}) => {151 if ((section === 'common') && (method === 'CollectionCreated')) {152 collectionId = parseInt(data[0].toString(), 10);153 }154 });155156 if (collectionId === null) {157 throw Error('No CollectionCreated event was found!');158 }159160 return collectionId;161 }162163 static extractTokensFromCreationResult(creationResult: ITransactionResult): {164 success: boolean, 165 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],166 } {167 if (creationResult.status !== this.transactionStatus.SUCCESS) {168 throw Error('Unable to create tokens!');169 }170 let success = false;171 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];172 creationResult.result.events.forEach(({event: {data, method, section}}) => {173 if (method === 'ExtrinsicSuccess') {174 success = true;175 } else if ((section === 'common') && (method === 'ItemCreated')) {176 tokens.push({177 collectionId: parseInt(data[0].toString(), 10),178 tokenId: parseInt(data[1].toString(), 10),179 owner: data[2].toHuman(),180 amount: data[3].toBigInt(),181 });182 }183 });184 return {success, tokens};185 }186187 static extractTokensFromBurnResult(burnResult: ITransactionResult): {188 success: boolean, 189 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],190 } {191 if (burnResult.status !== this.transactionStatus.SUCCESS) {192 throw Error('Unable to burn tokens!');193 }194 let success = false;195 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];196 burnResult.result.events.forEach(({event: {data, method, section}}) => {197 if (method === 'ExtrinsicSuccess') {198 success = true;199 } else if ((section === 'common') && (method === 'ItemDestroyed')) {200 tokens.push({201 collectionId: parseInt(data[0].toString(), 10),202 tokenId: parseInt(data[1].toString(), 10),203 owner: data[2].toHuman(),204 amount: data[3].toBigInt(),205 });206 }207 });208 return {success, tokens};209 }210211 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {212 let eventId = null;213 events.forEach(({event: {data, method, section}}) => {214 if ((section === expectedSection) && (method === expectedMethod)) {215 eventId = parseInt(data[0].toString(), 10);216 }217 });218219 if (eventId === null) {220 throw Error(`No ${expectedMethod} event was found!`);221 }222 return eventId === collectionId;223 }224225 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {226 const normalizeAddress = (address: string | ICrossAccountId) => {227 if(typeof address === 'string') return address;228 const obj = {} as any;229 Object.keys(address).forEach(k => {230 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];231 });232 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);233 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();234 return address;235 };236 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;237 events.forEach(({event: {data, method, section}}) => {238 if ((section === 'common') && (method === 'Transfer')) {239 const hData = (data as any).toJSON();240 transfer = {241 collectionId: hData[0],242 tokenId: hData[1],243 from: normalizeAddress(hData[2]),244 to: normalizeAddress(hData[3]),245 amount: BigInt(hData[4]),246 };247 }248 });249 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;250 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);251 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);252 isSuccess = isSuccess && amount === transfer.amount;253 return isSuccess;254 }255}256257class UniqueEventHelper {258 private static extractIndex(index: any): [number, number] | string {259 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];260 return index.toJSON();261 }262263 private static extractSub(data: any, subTypes: any): {[key: string]: any} {264 let obj: any = {};265 let index = 0;266267 if (data.entries) {268 for(const [key, value] of data.entries()) {269 obj[key] = this.extractData(value, subTypes[index]);270 index++;271 }272 } else obj = data.toJSON();273274 return obj;275 }276 277 private static extractData(data: any, type: any): any {278 if(!type) return data.toHuman();279 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();280 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();281 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);282 return data.toHuman();283 }284285 public static extractEvents(records: ITransactionResult): IEvent[] {286 const parsedEvents: IEvent[] = [];287288 records.result.events.forEach((record) => {289 const {event, phase} = record;290 const types = (event as any).typeDef;291292 const eventData: IEvent = {293 section: event.section.toString(),294 method: event.method.toString(),295 index: this.extractIndex(event.index),296 data: [],297 phase: phase.toJSON(),298 };299300 event.data.forEach((val: any, index: number) => {301 eventData.data.push(this.extractData(val, types[index]));302 });303304 parsedEvents.push(eventData);305 });306307 return parsedEvents;308 }309}310311class ChainHelperBase {312 transactionStatus = UniqueUtil.transactionStatus;313 chainLogType = UniqueUtil.chainLogType;314 util: typeof UniqueUtil;315 eventHelper: typeof UniqueEventHelper;316 logger: ILogger;317 api: ApiPromise | null;318 forcedNetwork: TUniqueNetworks | null;319 network: TUniqueNetworks | null;320 chainLog: IUniqueHelperLog[];321 children: ChainHelperBase[];322323 constructor(logger?: ILogger) {324 this.util = UniqueUtil;325 this.eventHelper = UniqueEventHelper;326 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();327 this.logger = logger;328 this.api = null;329 this.forcedNetwork = null;330 this.network = null;331 this.chainLog = [];332 this.children = [];333 }334335 getApi(): ApiPromise {336 if(this.api === null) throw Error('API not initialized');337 return this.api;338 }339340 clearChainLog(): void {341 this.chainLog = [];342 }343344 forceNetwork(value: TUniqueNetworks): void {345 this.forcedNetwork = value;346 }347348 async connect(wsEndpoint: string, listeners?: IApiListeners) {349 if (this.api !== null) throw Error('Already connected');350 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);351 this.api = api;352 this.network = network;353 }354355 async disconnect() {356 for (const child of this.children) {357 child.clearApi();358 }359360 if (this.api === null) return;361 await this.api.disconnect();362 this.clearApi();363 }364365 clearApi() {366 this.api = null;367 this.network = null;368 }369370 static async detectNetwork(api: ApiPromise): Promise<TUniqueNetworks> {371 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;372 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;373 return 'opal';374 }375376 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TUniqueNetworks> {377 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});378 await api.isReady;379380 const network = await this.detectNetwork(api);381382 await api.disconnect();383384 return network;385 }386387 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TUniqueNetworks | null): Promise<{388 api: ApiPromise;389 network: TUniqueNetworks;390 }> {391 if(typeof network === 'undefined' || network === null) network = 'opal';392 const supportedRPC = {393 opal: {394 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,395 },396 quartz: {397 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,398 },399 unique: {400 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,401 },402 };403 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);404 const rpc = supportedRPC[network];405406 // TODO: investigate how to replace rpc in runtime407 // api._rpcCore.addUserInterfaces(rpc);408409 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});410411 await api.isReadyOrError;412413 if (typeof listeners === 'undefined') listeners = {};414 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {415 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;416 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);417 }418419 return {api, network};420 }421422 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {423 const {events, status} = data;424 if (status.isReady) {425 return this.transactionStatus.NOT_READY;426 }427 if (status.isBroadcast) {428 return this.transactionStatus.NOT_READY;429 }430 if (status.isInBlock || status.isFinalized) {431 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');432 if (errors.length > 0) {433 return this.transactionStatus.FAIL;434 }435 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {436 return this.transactionStatus.SUCCESS;437 }438 }439440 return this.transactionStatus.FAIL;441 }442443 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {444 const sign = (callback: any) => {445 if(options !== null) return transaction.signAndSend(sender, options, callback);446 return transaction.signAndSend(sender, callback);447 };448 // eslint-disable-next-line no-async-promise-executor449 return new Promise(async (resolve, reject) => {450 try {451 const unsub = await sign((result: any) => {452 const status = this.getTransactionStatus(result);453454 if (status === this.transactionStatus.SUCCESS) {455 this.logger.log(`${label} successful`);456 unsub();457 resolve({result, status});458 } else if (status === this.transactionStatus.FAIL) {459 let moduleError = null;460461 if (result.hasOwnProperty('dispatchError')) {462 const dispatchError = result['dispatchError'];463464 if (dispatchError) {465 if (dispatchError.isModule) {466 const modErr = dispatchError.asModule;467 const errorMeta = dispatchError.registry.findMetaError(modErr);468469 moduleError = `${errorMeta.section}.${errorMeta.name}`;470 } else {471 moduleError = dispatchError.toHuman();472 }473 } else {474 this.logger.log(result, this.logger.level.ERROR);475 }476 }477478 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);479 unsub();480 reject({status, moduleError, result});481 }482 });483 } catch (e) {484 this.logger.log(e, this.logger.level.ERROR);485 reject(e);486 }487 });488 }489490 constructApiCall(apiCall: string, params: any[]) {491 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);492 let call = this.getApi() as any;493 for(const part of apiCall.slice(4).split('.')) {494 call = call[part];495 }496 return call(...params);497 }498499 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {500 if(this.api === null) throw Error('API not initialized');501 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);502503 const startTime = (new Date()).getTime();504 let result: ITransactionResult;505 let events: IEvent[] = [];506 try {507 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;508 events = this.eventHelper.extractEvents(result);509 }510 catch(e) {511 if(!(e as object).hasOwnProperty('status')) throw e;512 result = e as ITransactionResult;513 }514515 const endTime = (new Date()).getTime();516517 const log = {518 executedAt: endTime,519 executionTime: endTime - startTime,520 type: this.chainLogType.EXTRINSIC,521 status: result.status,522 call: extrinsic,523 signer: this.getSignerAddress(sender),524 params,525 } as IUniqueHelperLog;526527 if(result.status !== this.transactionStatus.SUCCESS) {528 if (result.moduleError) log.moduleError = result.moduleError;529 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;530 }531 if(events.length > 0) log.events = events;532533 this.chainLog.push(log);534535 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {536 if (result.moduleError) throw Error(`${result.moduleError}`);537 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));538 }539 return result;540 }541542 async callRpc(rpc: string, params?: any[]) {543 if(typeof params === 'undefined') params = [];544 if(this.api === null) throw Error('API not initialized');545 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);546547 const startTime = (new Date()).getTime();548 let result;549 let error = null;550 const log = {551 type: this.chainLogType.RPC,552 call: rpc,553 params,554 } as IUniqueHelperLog;555556 try {557 result = await this.constructApiCall(rpc, params);558 }559 catch(e) {560 error = e;561 }562563 const endTime = (new Date()).getTime();564565 log.executedAt = endTime;566 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';567 log.executionTime = endTime - startTime;568569 this.chainLog.push(log);570571 if(error !== null) throw error;572573 return result;574 }575576 getSignerAddress(signer: IKeyringPair | string): string {577 if(typeof signer === 'string') return signer;578 return signer.address;579 }580581 fetchAllPalletNames(): string[] {582 if(this.api === null) throw Error('API not initialized');583 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());584 }585586 fetchMissingPalletNames(requiredPallets: string[]): string[] {587 const palletNames = this.fetchAllPalletNames();588 return requiredPallets.filter(p => !palletNames.includes(p));589 }590}591592593class HelperGroup {594 helper: UniqueHelper;595596 constructor(uniqueHelper: UniqueHelper) {597 this.helper = uniqueHelper;598 }599}600601602class CollectionGroup extends HelperGroup {603 /**604 * Get number of blocks when sponsored transaction is available.605 *606 * @param collectionId ID of collection607 * @param tokenId ID of token608 * @param addressObj address for which the sponsorship is checked609 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});610 * @returns number of blocks or null if sponsorship hasn't been set611 */612 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {613 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();614 }615616 /**617 * Get the number of created collections.618 *619 * @returns number of created collections620 */621 async getTotalCount(): Promise<number> {622 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();623 }624625 /**626 * Get information about the collection with additional data,627 * including the number of tokens it contains, its administrators,628 * the normalized address of the collection's owner, and decoded name and description.629 *630 * @param collectionId ID of collection631 * @example await getData(2)632 * @returns collection information object633 */634 async getData(collectionId: number): Promise<{635 id: number;636 name: string;637 description: string;638 tokensCount: number;639 admins: CrossAccountId[];640 normalizedOwner: TSubstrateAccount;641 raw: any642 } | null> {643 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);644 const humanCollection = collection.toHuman(), collectionData = {645 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],646 raw: humanCollection,647 } as any, jsonCollection = collection.toJSON();648 if (humanCollection === null) return null;649 collectionData.raw.limits = jsonCollection.limits;650 collectionData.raw.permissions = jsonCollection.permissions;651 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);652 for (const key of ['name', 'description']) {653 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);654 }655656 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))657 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)658 : 0;659 collectionData.admins = await this.getAdmins(collectionId);660661 return collectionData;662 }663664 /**665 * Get the addresses of the collection's administrators, optionally normalized.666 *667 * @param collectionId ID of collection668 * @param normalize whether to normalize the addresses to the default ss58 format669 * @example await getAdmins(1)670 * @returns array of administrators671 */672 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {673 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();674675 return normalize676 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())677 : admins;678 }679680 /**681 * Get the addresses added to the collection allow-list, optionally normalized.682 * @param collectionId ID of collection683 * @param normalize whether to normalize the addresses to the default ss58 format684 * @example await getAllowList(1)685 * @returns array of allow-listed addresses686 */687 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {688 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();689 return normalize690 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())691 : allowListed;692 }693694 /**695 * Get the effective limits of the collection instead of null for default values696 *697 * @param collectionId ID of collection698 * @example await getEffectiveLimits(2)699 * @returns object of collection limits700 */701 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {702 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();703 }704705 /**706 * Burns the collection if the signer has sufficient permissions and collection is empty.707 *708 * @param signer keyring of signer709 * @param collectionId ID of collection710 * @example await helper.collection.burn(aliceKeyring, 3);711 * @returns ```true``` if extrinsic success, otherwise ```false```712 */713 async burn(signer: TSigner, collectionId: number): Promise<boolean> {714 const result = await this.helper.executeExtrinsic(715 signer,716 'api.tx.unique.destroyCollection', [collectionId],717 true,718 );719720 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');721 }722723 /**724 * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.725 *726 * @param signer keyring of signer727 * @param collectionId ID of collection728 * @param sponsorAddress Sponsor substrate address729 * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")730 * @returns ```true``` if extrinsic success, otherwise ```false```731 */732 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {733 const result = await this.helper.executeExtrinsic(734 signer,735 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],736 true,737 );738739 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorSet');740 }741742 /**743 * Confirms consent to sponsor the collection on behalf of the signer.744 *745 * @param signer keyring of signer746 * @param collectionId ID of collection747 * @example confirmSponsorship(aliceKeyring, 10)748 * @returns ```true``` if extrinsic success, otherwise ```false```749 */750 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {751 const result = await this.helper.executeExtrinsic(752 signer,753 'api.tx.unique.confirmSponsorship', [collectionId],754 true,755 );756757 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'SponsorshipConfirmed');758 }759760 /**761 * Removes the sponsor of a collection, regardless if it consented or not.762 *763 * @param signer keyring of signer764 * @param collectionId ID of collection765 * @example removeSponsor(aliceKeyring, 10)766 * @returns ```true``` if extrinsic success, otherwise ```false```767 */768 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {769 const result = await this.helper.executeExtrinsic(770 signer,771 'api.tx.unique.removeCollectionSponsor', [collectionId],772 true,773 );774775 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorRemoved');776 }777778 /**779 * Sets the limits of the collection. At least one limit must be specified for a correct call.780 *781 * @param signer keyring of signer782 * @param collectionId ID of collection783 * @param limits collection limits object784 * @example785 * await setLimits(786 * aliceKeyring,787 * 10,788 * {789 * sponsorTransferTimeout: 0,790 * ownerCanDestroy: false791 * }792 * )793 * @returns ```true``` if extrinsic success, otherwise ```false```794 */795 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {796 const result = await this.helper.executeExtrinsic(797 signer,798 'api.tx.unique.setCollectionLimits', [collectionId, limits],799 true,800 );801802 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionLimitSet');803 }804805 /**806 * Changes the owner of the collection to the new Substrate address.807 *808 * @param signer keyring of signer809 * @param collectionId ID of collection810 * @param ownerAddress substrate address of new owner811 * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")812 * @returns ```true``` if extrinsic success, otherwise ```false```813 */814 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {815 const result = await this.helper.executeExtrinsic(816 signer,817 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],818 true,819 );820821 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionOwnedChanged');822 }823824 /**825 * Adds a collection administrator.826 *827 * @param signer keyring of signer828 * @param collectionId ID of collection829 * @param adminAddressObj Administrator address (substrate or ethereum)830 * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})831 * @returns ```true``` if extrinsic success, otherwise ```false```832 */833 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {834 const result = await this.helper.executeExtrinsic(835 signer,836 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],837 true,838 );839840 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminAdded');841 }842843 /**844 * Removes a collection administrator.845 *846 * @param signer keyring of signer847 * @param collectionId ID of collection848 * @param adminAddressObj Administrator address (substrate or ethereum)849 * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})850 * @returns ```true``` if extrinsic success, otherwise ```false```851 */852 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {853 const result = await this.helper.executeExtrinsic(854 signer,855 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],856 true,857 );858859 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminRemoved');860 }861862 /**863 * Check if user is in allow list.864 * 865 * @param collectionId ID of collection866 * @param user Account to check867 * @example await getAdmins(1)868 * @returns is user in allow list869 */870 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {871 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();872 }873874 /**875 * Adds an address to allow list876 * @param signer keyring of signer877 * @param collectionId ID of collection878 * @param addressObj address to add to the allow list879 * @returns ```true``` if extrinsic success, otherwise ```false```880 */881 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {882 const result = await this.helper.executeExtrinsic(883 signer,884 'api.tx.unique.addToAllowList', [collectionId, addressObj],885 true,886 );887888 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressAdded');889 }890891 /**892 * Removes an address from allow list893 *894 * @param signer keyring of signer895 * @param collectionId ID of collection896 * @param addressObj address to remove from the allow list897 * @returns ```true``` if extrinsic success, otherwise ```false```898 */899 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {900 const result = await this.helper.executeExtrinsic(901 signer,902 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],903 true,904 );905906 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressRemoved');907 }908909 /**910 * Sets onchain permissions for selected collection.911 *912 * @param signer keyring of signer913 * @param collectionId ID of collection914 * @param permissions collection permissions object915 * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});916 * @returns ```true``` if extrinsic success, otherwise ```false```917 */918 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {919 const result = await this.helper.executeExtrinsic(920 signer,921 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],922 true,923 );924925 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionPermissionSet');926 }927928 /**929 * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.930 *931 * @param signer keyring of signer932 * @param collectionId ID of collection933 * @param permissions nesting permissions object934 * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});935 * @returns ```true``` if extrinsic success, otherwise ```false```936 */937 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {938 return await this.setPermissions(signer, collectionId, {nesting: permissions});939 }940941 /**942 * Disables nesting for selected collection.943 *944 * @param signer keyring of signer945 * @param collectionId ID of collection946 * @example disableNesting(aliceKeyring, 10);947 * @returns ```true``` if extrinsic success, otherwise ```false```948 */949 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {950 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});951 }952953 /**954 * Sets onchain properties to the collection.955 *956 * @param signer keyring of signer957 * @param collectionId ID of collection958 * @param properties array of property objects959 * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);960 * @returns ```true``` if extrinsic success, otherwise ```false```961 */962 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {963 const result = await this.helper.executeExtrinsic(964 signer,965 'api.tx.unique.setCollectionProperties', [collectionId, properties],966 true,967 );968969 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');970 }971972 /**973 * Get collection properties.974 * 975 * @param collectionId ID of collection976 * @param propertyKeys optionally filter the returned properties to only these keys977 * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);978 * @returns array of key-value pairs979 */980 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {981 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();982 }983984 /**985 * Deletes onchain properties from the collection.986 *987 * @param signer keyring of signer988 * @param collectionId ID of collection989 * @param propertyKeys array of property keys to delete990 * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);991 * @returns ```true``` if extrinsic success, otherwise ```false```992 */993 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {994 const result = await this.helper.executeExtrinsic(995 signer,996 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],997 true,998 );9991000 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1001 }10021003 /**1004 * Changes the owner of the token.1005 *1006 * @param signer keyring of signer1007 * @param collectionId ID of collection1008 * @param tokenId ID of token1009 * @param addressObj address of a new owner1010 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1011 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1012 * @returns true if the token success, otherwise false1013 */1014 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1015 const result = await this.helper.executeExtrinsic(1016 signer,1017 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1018 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1019 );10201021 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1022 }10231024 /**1025 *1026 * Change ownership of a token(s) on behalf of the owner.1027 *1028 * @param signer keyring of signer1029 * @param collectionId ID of collection1030 * @param tokenId ID of token1031 * @param fromAddressObj address on behalf of which the token will be sent1032 * @param toAddressObj new token owner1033 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1034 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1035 * @returns true if the token success, otherwise false1036 */1037 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1038 const result = await this.helper.executeExtrinsic(1039 signer,1040 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1041 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1042 );1043 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1044 }10451046 /**1047 *1048 * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1049 *1050 * @param signer keyring of signer1051 * @param collectionId ID of collection1052 * @param tokenId ID of token1053 * @param amount amount of tokens to be burned. For NFT must be set to 1n1054 * @example burnToken(aliceKeyring, 10, 5);1055 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1056 */1057 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1058 const burnResult = await this.helper.executeExtrinsic(1059 signer,1060 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1061 true, // `Unable to burn token for ${label}`,1062 );1063 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1064 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1065 return burnedTokens.success;1066 }10671068 /**1069 * Destroys a concrete instance of NFT on behalf of the owner1070 *1071 * @param signer keyring of signer1072 * @param collectionId ID of collection1073 * @param tokenId ID of token1074 * @param fromAddressObj address on behalf of which the token will be burnt1075 * @param amount amount of tokens to be burned. For NFT must be set to 1n1076 * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1077 * @returns ```true``` if extrinsic success, otherwise ```false```1078 */1079 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1080 const burnResult = await this.helper.executeExtrinsic(1081 signer,1082 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1083 true, // `Unable to burn token from for ${label}`,1084 );1085 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1086 return burnedTokens.success && burnedTokens.tokens.length > 0;1087 }10881089 /**1090 * Set, change, or remove approved address to transfer the ownership of the NFT.1091 *1092 * @param signer keyring of signer1093 * @param collectionId ID of collection1094 * @param tokenId ID of token1095 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1096 * @param amount amount of token to be approved. For NFT must be set to 1n1097 * @returns ```true``` if extrinsic success, otherwise ```false```1098 */1099 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1100 const approveResult = await this.helper.executeExtrinsic(1101 signer,1102 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1103 true, // `Unable to approve token for ${label}`,1104 );11051106 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1107 }11081109 /**1110 * Get the amount of token pieces approved to transfer or burn. Normally 0.1111 *1112 * @param collectionId ID of collection1113 * @param tokenId ID of token1114 * @param toAccountObj address which is approved to use token pieces1115 * @param fromAccountObj address which may have allowed the use of its owned tokens1116 * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1117 * @returns number of approved to transfer pieces1118 */1119 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1120 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1121 }11221123 /**1124 * Get the last created token ID in a collection1125 *1126 * @param collectionId ID of collection1127 * @example getLastTokenId(10);1128 * @returns id of the last created token1129 */1130 async getLastTokenId(collectionId: number): Promise<number> {1131 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1132 }11331134 /**1135 * Check if token exists1136 *1137 * @param collectionId ID of collection1138 * @param tokenId ID of token1139 * @example doesTokenExist(10, 20);1140 * @returns true if the token exists, otherwise false1141 */1142 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1143 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1144 }1145}11461147class NFTnRFT extends CollectionGroup {1148 /**1149 * Get tokens owned by account1150 *1151 * @param collectionId ID of collection1152 * @param addressObj tokens owner1153 * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1154 * @returns array of token ids owned by account1155 */1156 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1157 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1158 }11591160 /**1161 * Get token data1162 *1163 * @param collectionId ID of collection1164 * @param tokenId ID of token1165 * @param propertyKeys optionally filter the token properties to only these keys1166 * @param blockHashAt optionally query the data at some block with this hash1167 * @example getToken(10, 5);1168 * @returns human readable token data1169 */1170 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1171 properties: IProperty[];1172 owner: CrossAccountId;1173 normalizedOwner: CrossAccountId;1174 }| null> {1175 let tokenData;1176 if(typeof blockHashAt === 'undefined') {1177 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1178 }1179 else {1180 if(propertyKeys.length == 0) {1181 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1182 if(!collection) return null;1183 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1184 }1185 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1186 }1187 tokenData = tokenData.toHuman();1188 if (tokenData === null || tokenData.owner === null) return null;1189 const owner = {} as any;1190 for (const key of Object.keys(tokenData.owner)) {1191 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate' 1192 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key]) 1193 : tokenData.owner[key];1194 }1195 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1196 return tokenData;1197 }11981199 /**1200 * Set permissions to change token properties1201 *1202 * @param signer keyring of signer1203 * @param collectionId ID of collection1204 * @param permissions permissions to change a property by the collection admin or token owner1205 * @example setTokenPropertyPermissions(1206 * aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1207 * )1208 * @returns true if extrinsic success otherwise false1209 */1210 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1211 const result = await this.helper.executeExtrinsic(1212 signer,1213 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1214 true,1215 );12161217 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1218 }12191220 /**1221 * Get token property permissions.1222 * 1223 * @param collectionId ID of collection1224 * @param propertyKeys optionally filter the returned property permissions to only these keys1225 * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1226 * @returns array of key-permission pairs1227 */1228 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1229 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1230 }12311232 /**1233 * Set token properties1234 *1235 * @param signer keyring of signer1236 * @param collectionId ID of collection1237 * @param tokenId ID of token1238 * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1239 * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1240 * @returns ```true``` if extrinsic success, otherwise ```false```1241 */1242 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1243 const result = await this.helper.executeExtrinsic(1244 signer,1245 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1246 true,1247 );12481249 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1250 }12511252 /**1253 * Get properties, metadata assigned to a token.1254 * 1255 * @param collectionId ID of collection1256 * @param tokenId ID of token1257 * @param propertyKeys optionally filter the returned properties to only these keys1258 * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1259 * @returns array of key-value pairs1260 */1261 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1262 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1263 }12641265 /**1266 * Delete the provided properties of a token1267 * @param signer keyring of signer1268 * @param collectionId ID of collection1269 * @param tokenId ID of token1270 * @param propertyKeys property keys to be deleted1271 * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1272 * @returns ```true``` if extrinsic success, otherwise ```false```1273 */1274 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1275 const result = await this.helper.executeExtrinsic(1276 signer,1277 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1278 true,1279 );12801281 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1282 }12831284 /**1285 * Mint new collection1286 *1287 * @param signer keyring of signer1288 * @param collectionOptions basic collection options and properties1289 * @param mode NFT or RFT type of a collection1290 * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1291 * @returns object of the created collection1292 */1293 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1294 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1295 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1296 for (const key of ['name', 'description', 'tokenPrefix']) {1297 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);1298 }1299 const creationResult = await this.helper.executeExtrinsic(1300 signer,1301 'api.tx.unique.createCollectionEx', [collectionOptions],1302 true, // errorLabel,1303 );1304 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1305 }13061307 getCollectionObject(_collectionId: number): any {1308 return null;1309 }13101311 getTokenObject(_collectionId: number, _tokenId: number): any {1312 return null;1313 }1314}131513161317class NFTGroup extends NFTnRFT {1318 /**1319 * Get collection object1320 * @param collectionId ID of collection1321 * @example getCollectionObject(2);1322 * @returns instance of UniqueNFTCollection1323 */1324 getCollectionObject(collectionId: number): UniqueNFTCollection {1325 return new UniqueNFTCollection(collectionId, this.helper);1326 }13271328 /**1329 * Get token object1330 * @param collectionId ID of collection1331 * @param tokenId ID of token1332 * @example getTokenObject(10, 5);1333 * @returns instance of UniqueNFTToken1334 */1335 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1336 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1337 }13381339 /**1340 * Get token's owner1341 * @param collectionId ID of collection1342 * @param tokenId ID of token1343 * @param blockHashAt optionally query the data at the block with this hash1344 * @example getTokenOwner(10, 5);1345 * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1346 */1347 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1348 let owner;1349 if (typeof blockHashAt === 'undefined') {1350 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1351 } else {1352 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1353 }1354 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1355 }13561357 /**1358 * Is token approved to transfer1359 * @param collectionId ID of collection1360 * @param tokenId ID of token1361 * @param toAccountObj address to be approved1362 * @returns ```true``` if extrinsic success, otherwise ```false```1363 */1364 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1365 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1366 }13671368 /**1369 * Changes the owner of the token.1370 *1371 * @param signer keyring of signer1372 * @param collectionId ID of collection1373 * @param tokenId ID of token1374 * @param addressObj address of a new owner1375 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1376 * @returns ```true``` if extrinsic success, otherwise ```false```1377 */1378 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1379 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1380 }13811382 /**1383 *1384 * Change ownership of a NFT on behalf of the owner.1385 *1386 * @param signer keyring of signer1387 * @param collectionId ID of collection1388 * @param tokenId ID of token1389 * @param fromAddressObj address on behalf of which the token will be sent1390 * @param toAddressObj new token owner1391 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1392 * @returns ```true``` if extrinsic success, otherwise ```false```1393 */1394 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1395 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1396 }13971398 /**1399 * Recursively find the address that owns the token1400 * @param collectionId ID of collection1401 * @param tokenId ID of token1402 * @param blockHashAt1403 * @example getTokenTopmostOwner(10, 5);1404 * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1405 */1406 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1407 let owner;1408 if (typeof blockHashAt === 'undefined') {1409 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1410 } else {1411 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1412 }14131414 if (owner === null) return null;14151416 return owner.toHuman();1417 }14181419 /**1420 * Get tokens nested in the provided token1421 * @param collectionId ID of collection1422 * @param tokenId ID of token1423 * @param blockHashAt optionally query the data at the block with this hash1424 * @example getTokenChildren(10, 5);1425 * @returns tokens whose depth of nesting is <= 51426 */1427 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1428 let children;1429 if(typeof blockHashAt === 'undefined') {1430 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1431 } else {1432 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1433 }14341435 return children.toJSON().map((x: any) => {1436 return {collectionId: x.collection, tokenId: x.token};1437 });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 * Mint new collection1477 * @param signer keyring of signer1478 * @param collectionOptions Collection options1479 * @example1480 * mintCollection(aliceKeyring, {1481 * name: 'New',1482 * description: 'New collection',1483 * tokenPrefix: 'NEW',1484 * })1485 * @returns object of the created collection1486 */1487 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1488 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1489 }14901491 /**1492 * Mint new token1493 * @param signer keyring of signer1494 * @param data token data1495 * @returns created token object1496 */1497 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1498 const creationResult = await this.helper.executeExtrinsic(1499 signer,1500 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1501 nft: {1502 properties: data.properties,1503 },1504 }],1505 true,1506 );1507 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1508 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1509 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1510 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1511 }15121513 /**1514 * Mint multiple NFT tokens1515 * @param signer keyring of signer1516 * @param collectionId ID of collection1517 * @param tokens array of tokens with owner and properties1518 * @example1519 * mintMultipleTokens(aliceKeyring, 10, [{1520 * owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1521 * properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1522 * },{1523 * owner: {Ethereum: "0x9F0583DbB855d..."},1524 * properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1525 * }]);1526 * @returns ```true``` if extrinsic success, otherwise ```false```1527 */1528 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1529 const creationResult = await this.helper.executeExtrinsic(1530 signer,1531 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1532 true,1533 );1534 const collection = this.getCollectionObject(collectionId);1535 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1536 }15371538 /**1539 * Mint multiple NFT tokens with one owner1540 * @param signer keyring of signer1541 * @param collectionId ID of collection1542 * @param owner tokens owner1543 * @param tokens array of tokens with owner and properties1544 * @example1545 * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1546 * properties: [{1547 * key: "gender",1548 * value: "female",1549 * },{1550 * key: "age",1551 * value: "33",1552 * }],1553 * }]);1554 * @returns array of newly created tokens1555 */1556 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1557 const rawTokens = [];1558 for (const token of tokens) {1559 const raw = {NFT: {properties: token.properties}};1560 rawTokens.push(raw);1561 }1562 const creationResult = await this.helper.executeExtrinsic(1563 signer,1564 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1565 true,1566 );1567 const collection = this.getCollectionObject(collectionId);1568 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1569 }15701571 /**1572 * Set, change, or remove approved address to transfer the ownership of the NFT.1573 *1574 * @param signer keyring of signer1575 * @param collectionId ID of collection1576 * @param tokenId ID of token1577 * @param toAddressObj address to approve1578 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1579 * @returns ```true``` if extrinsic success, otherwise ```false```1580 */1581 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId) {1582 return super.approveToken(signer, collectionId, tokenId, toAddressObj, 1n);1583 }1584}158515861587class RFTGroup extends NFTnRFT {1588 /**1589 * Get collection object1590 * @param collectionId ID of collection1591 * @example getCollectionObject(2);1592 * @returns instance of UniqueRFTCollection1593 */1594 getCollectionObject(collectionId: number): UniqueRFTCollection {1595 return new UniqueRFTCollection(collectionId, this.helper);1596 }15971598 /**1599 * Get token object1600 * @param collectionId ID of collection1601 * @param tokenId ID of token1602 * @example getTokenObject(10, 5);1603 * @returns instance of UniqueNFTToken1604 */1605 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1606 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1607 }16081609 /**1610 * Get top 10 token owners with the largest number of pieces1611 * @param collectionId ID of collection1612 * @param tokenId ID of token1613 * @example getTokenTop10Owners(10, 5);1614 * @returns array of top 10 owners1615 */1616 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1617 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1618 }16191620 /**1621 * Get number of pieces owned by address1622 * @param collectionId ID of collection1623 * @param tokenId ID of token1624 * @param addressObj address token owner1625 * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1626 * @returns number of pieces ownerd by address1627 */1628 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1629 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1630 }16311632 /**1633 * Transfer pieces of token to another address1634 * @param signer keyring of signer1635 * @param collectionId ID of collection1636 * @param tokenId ID of token1637 * @param addressObj address of a new owner1638 * @param amount number of pieces to be transfered1639 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1640 * @returns ```true``` if extrinsic success, otherwise ```false```1641 */1642 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1643 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1644 }16451646 /**1647 * Change ownership of some pieces of RFT on behalf of the owner.1648 * @param signer keyring of signer1649 * @param collectionId ID of collection1650 * @param tokenId ID of token1651 * @param fromAddressObj address on behalf of which the token will be sent1652 * @param toAddressObj new token owner1653 * @param amount number of pieces to be transfered1654 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1655 * @returns ```true``` if extrinsic success, otherwise ```false```1656 */1657 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1658 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1659 }16601661 /**1662 * Mint new collection1663 * @param signer keyring of signer1664 * @param collectionOptions Collection options1665 * @example1666 * mintCollection(aliceKeyring, {1667 * name: 'New',1668 * description: 'New collection',1669 * tokenPrefix: 'NEW',1670 * })1671 * @returns object of the created collection1672 */1673 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1674 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1675 }16761677 /**1678 * Mint new token1679 * @param signer keyring of signer1680 * @param data token data1681 * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1682 * @returns created token object1683 */1684 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1685 const creationResult = await this.helper.executeExtrinsic(1686 signer,1687 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1688 refungible: {1689 pieces: data.pieces,1690 properties: data.properties,1691 },1692 }],1693 true,1694 );1695 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1696 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1697 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1698 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1699 }17001701 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1702 throw Error('Not implemented');1703 const creationResult = await this.helper.executeExtrinsic(1704 signer,1705 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1706 true, // `Unable to mint RFT tokens for ${label}`,1707 );1708 const collection = this.getCollectionObject(collectionId);1709 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1710 }17111712 /**1713 * Mint multiple RFT tokens with one owner1714 * @param signer keyring of signer1715 * @param collectionId ID of collection1716 * @param owner tokens owner1717 * @param tokens array of tokens with properties and pieces1718 * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1719 * @returns array of newly created RFT tokens1720 */1721 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1722 const rawTokens = [];1723 for (const token of tokens) {1724 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1725 rawTokens.push(raw);1726 }1727 const creationResult = await this.helper.executeExtrinsic(1728 signer,1729 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1730 true,1731 );1732 const collection = this.getCollectionObject(collectionId);1733 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1734 }17351736 /**1737 * Destroys a concrete instance of RFT.1738 * @param signer keyring of signer1739 * @param collectionId ID of collection1740 * @param tokenId ID of token1741 * @param amount number of pieces to be burnt1742 * @example burnToken(aliceKeyring, 10, 5);1743 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1744 */1745 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1746 return await super.burnToken(signer, collectionId, tokenId, amount);1747 }17481749 /**1750 * Destroys a concrete instance of RFT on behalf of the owner.1751 * @param signer keyring of signer1752 * @param collectionId ID of collection1753 * @param tokenId ID of token1754 * @param fromAddressObj address on behalf of which the token will be burnt1755 * @param amount number of pieces to be burnt1756 * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1757 * @returns ```true``` if extrinsic success, otherwise ```false```1758 */1759 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1760 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1761 }17621763 /**1764 * Set, change, or remove approved address to transfer the ownership of the RFT.1765 *1766 * @param signer keyring of signer1767 * @param collectionId ID of collection1768 * @param tokenId ID of token1769 * @param toAddressObj address to approve1770 * @param amount number of pieces to be approved1771 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);1772 * @returns true if the token success, otherwise false1773 */1774 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1775 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1776 }17771778 /**1779 * Get total number of pieces1780 * @param collectionId ID of collection1781 * @param tokenId ID of token1782 * @example getTokenTotalPieces(10, 5);1783 * @returns number of pieces1784 */1785 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {1786 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();1787 }17881789 /**1790 * Change number of token pieces. Signer must be the owner of all token pieces.1791 * @param signer keyring of signer1792 * @param collectionId ID of collection1793 * @param tokenId ID of token1794 * @param amount new number of pieces1795 * @example repartitionToken(aliceKeyring, 10, 5, 12345n);1796 * @returns true if the repartion was success, otherwise false1797 */1798 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {1799 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);1800 const repartitionResult = await this.helper.executeExtrinsic(1801 signer,1802 'api.tx.unique.repartition', [collectionId, tokenId, amount],1803 true,1804 );1805 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');1806 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');1807 }1808}180918101811class FTGroup extends CollectionGroup {1812 /**1813 * Get collection object1814 * @param collectionId ID of collection1815 * @example getCollectionObject(2);1816 * @returns instance of UniqueFTCollection1817 */1818 getCollectionObject(collectionId: number): UniqueFTCollection {1819 return new UniqueFTCollection(collectionId, this.helper);1820 }18211822 /**1823 * Mint new fungible collection1824 * @param signer keyring of signer1825 * @param collectionOptions Collection options1826 * @param decimalPoints number of token decimals1827 * @example1828 * mintCollection(aliceKeyring, {1829 * name: 'New',1830 * description: 'New collection',1831 * tokenPrefix: 'NEW',1832 * }, 18)1833 * @returns newly created fungible collection1834 */1835 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {1836 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1837 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');1838 collectionOptions.mode = {fungible: decimalPoints};1839 for (const key of ['name', 'description', 'tokenPrefix']) {1840 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);1841 }1842 const creationResult = await this.helper.executeExtrinsic(1843 signer,1844 'api.tx.unique.createCollectionEx', [collectionOptions],1845 true,1846 );1847 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1848 }18491850 /**1851 * Mint tokens1852 * @param signer keyring of signer1853 * @param collectionId ID of collection1854 * @param owner address owner of new tokens1855 * @param amount amount of tokens to be meanted1856 * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);1857 * @returns ```true``` if extrinsic success, otherwise ```false```1858 */1859 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {1860 const creationResult = await this.helper.executeExtrinsic(1861 signer,1862 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {1863 fungible: {1864 value: amount,1865 },1866 }],1867 true, // `Unable to mint fungible tokens for ${label}`,1868 );1869 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1870 }18711872 /**1873 * Mint multiple Fungible tokens with one owner1874 * @param signer keyring of signer1875 * @param collectionId ID of collection1876 * @param owner tokens owner1877 * @param tokens array of tokens with properties and pieces1878 * @returns ```true``` if extrinsic success, otherwise ```false```1879 */1880 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {1881 const rawTokens = [];1882 for (const token of tokens) {1883 const raw = {Fungible: {Value: token.value}};1884 rawTokens.push(raw);1885 }1886 const creationResult = await this.helper.executeExtrinsic(1887 signer,1888 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1889 true,1890 );1891 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1892 }18931894 /**1895 * Get the top 10 owners with the largest balance for the Fungible collection1896 * @param collectionId ID of collection1897 * @example getTop10Owners(10);1898 * @returns array of ```ICrossAccountId```1899 */1900 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {1901 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1902 }19031904 /**1905 * Get account balance1906 * @param collectionId ID of collection1907 * @param addressObj address of owner1908 * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})1909 * @returns amount of fungible tokens owned by address1910 */1911 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {1912 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();1913 }19141915 /**1916 * Transfer tokens to address1917 * @param signer keyring of signer1918 * @param collectionId ID of collection1919 * @param toAddressObj address recipient1920 * @param amount amount of tokens to be sent1921 * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);1922 * @returns ```true``` if extrinsic success, otherwise ```false```1923 */1924 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {1925 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);1926 }19271928 /**1929 * Transfer some tokens on behalf of the owner.1930 * @param signer keyring of signer1931 * @param collectionId ID of collection1932 * @param fromAddressObj address on behalf of which tokens will be sent1933 * @param toAddressObj address where token to be sent1934 * @param amount number of tokens to be sent1935 * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);1936 * @returns ```true``` if extrinsic success, otherwise ```false```1937 */1938 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1939 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);1940 }19411942 /**1943 * Destroy some amount of tokens1944 * @param signer keyring of signer1945 * @param collectionId ID of collection1946 * @param amount amount of tokens to be destroyed1947 * @example burnTokens(aliceKeyring, 10, 1000n);1948 * @returns ```true``` if extrinsic success, otherwise ```false```1949 */1950 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {1951 return await super.burnToken(signer, collectionId, 0, amount);1952 }19531954 /**1955 * Burn some tokens on behalf of the owner.1956 * @param signer keyring of signer1957 * @param collectionId ID of collection1958 * @param fromAddressObj address on behalf of which tokens will be burnt1959 * @param amount amount of tokens to be burnt1960 * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);1961 * @returns ```true``` if extrinsic success, otherwise ```false```1962 */1963 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1964 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);1965 }19661967 /**1968 * Get total collection supply1969 * @param collectionId1970 * @returns1971 */1972 async getTotalPieces(collectionId: number): Promise<bigint> {1973 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();1974 }19751976 /**1977 * Set, change, or remove approved address to transfer tokens.1978 *1979 * @param signer keyring of signer1980 * @param collectionId ID of collection1981 * @param toAddressObj address to be approved1982 * @param amount amount of tokens to be approved1983 * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)1984 * @returns ```true``` if extrinsic success, otherwise ```false```1985 */1986 async approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {1987 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);1988 }19891990 /**1991 * Get amount of fungible tokens approved to transfer1992 * @param collectionId ID of collection1993 * @param fromAddressObj owner of tokens1994 * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner1995 * @returns number of tokens approved for the transfer1996 */1997 async getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {1998 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);1999 }2000}200120022003class ChainGroup extends HelperGroup {2004 /**2005 * Get system properties of a chain2006 * @example getChainProperties();2007 * @returns ss58Format, token decimals, and token symbol2008 */2009 getChainProperties(): IChainProperties {2010 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2011 return {2012 ss58Format: properties.ss58Format.toJSON(),2013 tokenDecimals: properties.tokenDecimals.toJSON(),2014 tokenSymbol: properties.tokenSymbol.toJSON(),2015 };2016 }20172018 /**2019 * Get chain header2020 * @example getLatestBlockNumber();2021 * @returns the number of the last block2022 */2023 async getLatestBlockNumber(): Promise<number> {2024 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2025 }20262027 /**2028 * Get block hash by block number2029 * @param blockNumber number of block2030 * @example getBlockHashByNumber(12345);2031 * @returns hash of a block2032 */2033 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2034 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2035 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2036 return blockHash;2037 }20382039 // TODO add docs2040 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2041 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2042 if (!blockHash) return null;2043 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2044 }20452046 /**2047 * Get account nonce2048 * @param address substrate address2049 * @example getNonce("5GrwvaEF5zXb26Fz...");2050 * @returns number, account's nonce2051 */2052 async getNonce(address: TSubstrateAccount): Promise<number> {2053 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2054 }2055}205620572058class BalanceGroup extends HelperGroup {2059 getCollectionCreationPrice(): bigint {2060 return 2n * this.helper.balance.getOneTokenNominal();2061 }2062 /**2063 * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2064 * @example getOneTokenNominal()2065 * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2066 */2067 getOneTokenNominal(): bigint {2068 const chainProperties = this.helper.chain.getChainProperties();2069 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2070 }20712072 /**2073 * Get substrate address balance2074 * @param address substrate address2075 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2076 * @returns amount of tokens on address2077 */2078 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2079 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2080 }20812082 /**2083 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2084 * @param address substrate address2085 * @returns2086 */2087 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2088 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2089 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2090 }20912092 /**2093 * Get ethereum address balance2094 * @param address ethereum address2095 * @example getEthereum("0x9F0583DbB855d...")2096 * @returns amount of tokens on address2097 */2098 async getEthereum(address: TEthereumAccount): Promise<bigint> {2099 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2100 }21012102 /**2103 * Transfer tokens to substrate address2104 * @param signer keyring of signer2105 * @param address substrate address of a recipient2106 * @param amount amount of tokens to be transfered2107 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2108 * @returns ```true``` if extrinsic success, otherwise ```false```2109 */2110 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2111 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}`*/);21122113 let transfer = {from: null, to: null, amount: 0n} as any;2114 result.result.events.forEach(({event: {data, method, section}}) => {2115 if ((section === 'balances') && (method === 'Transfer')) {2116 transfer = {2117 from: this.helper.address.normalizeSubstrate(data[0]),2118 to: this.helper.address.normalizeSubstrate(data[1]),2119 amount: BigInt(data[2]),2120 };2121 }2122 });2123 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from 2124 && this.helper.address.normalizeSubstrate(address) === transfer.to 2125 && BigInt(amount) === transfer.amount;2126 return isSuccess;2127 }2128}212921302131class AddressGroup extends HelperGroup {2132 /**2133 * Normalizes the address to the specified ss58 format, by default ```42```.2134 * @param address substrate address2135 * @param ss58Format format for address conversion, by default ```42```2136 * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2137 * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2138 */2139 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2140 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2141 }21422143 /**2144 * Get address in the connected chain format2145 * @param address substrate address2146 * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2147 * @returns address in chain format2148 */2149 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2150 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2151 }21522153 /**2154 * Get substrate mirror of an ethereum address2155 * @param ethAddress ethereum address2156 * @param toChainFormat false for normalized account2157 * @example ethToSubstrate('0x9F0583DbB855d...')2158 * @returns substrate mirror of a provided ethereum address2159 */2160 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2161 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2162 }21632164 /**2165 * Get ethereum mirror of a substrate address2166 * @param subAddress substrate account2167 * @example substrateToEth("5DnSF6RRjwteE3BrC...")2168 * @returns ethereum mirror of a provided substrate address2169 */2170 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2171 return CrossAccountId.translateSubToEth(subAddress);2172 }2173}21742175class StakingGroup extends HelperGroup {2176 /**2177 * Stake tokens for App Promotion2178 * @param signer keyring of signer2179 * @param amountToStake amount of tokens to stake2180 * @param label extra label for log2181 * @returns2182 */2183 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2184 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2185 const _stakeResult = await this.helper.executeExtrinsic(2186 signer, 'api.tx.appPromotion.stake',2187 [amountToStake], true,2188 );2189 // TODO extract info from stakeResult2190 return true;2191 }21922193 /**2194 * Unstake tokens for App Promotion2195 * @param signer keyring of signer2196 * @param amountToUnstake amount of tokens to unstake2197 * @param label extra label for log2198 * @returns block number where balances will be unlocked2199 */2200 async unstake(signer: TSigner, label?: string): Promise<number> {2201 if(typeof label === 'undefined') label = `${signer.address}`;2202 const _unstakeResult = await this.helper.executeExtrinsic(2203 signer, 'api.tx.appPromotion.unstake',2204 [], true,2205 );2206 // TODO extract block number fron events2207 return 1;2208 }22092210 /**2211 * Get total staked amount for address2212 * @param address substrate or ethereum address2213 * @returns total staked amount2214 */2215 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2216 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2217 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2218 }22192220 /**2221 * Get total staked per block2222 * @param address substrate or ethereum address2223 * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2224 */2225 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2226 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2227 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2228 return { 2229 block: block.toBigInt(),2230 amount: amount.toBigInt(),2231 };2232 });2233 }22342235 /**2236 * Get total pending unstake amount for address2237 * @param address substrate or ethereum address2238 * @returns total pending unstake amount2239 */2240 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2241 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2242 }22432244 /**2245 * Get pending unstake amount per block for address2246 * @param address substrate or ethereum address2247 * @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 block2248 */2249 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2250 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2251 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2252 return {2253 block: block.toBigInt(),2254 amount: amount.toBigInt(),2255 };2256 });2257 return result;2258 }2259}22602261class SchedulerGroup extends HelperGroup {2262 constructor(helper: UniqueHelper) {2263 super(helper);2264 }22652266 async cancelScheduled(signer: TSigner, scheduledId: string) {2267 return this.helper.executeExtrinsic(2268 signer,2269 'api.tx.scheduler.cancelNamed',2270 [scheduledId],2271 true,2272 );2273 }22742275 async changePriority(signer: TSigner, scheduledId: string, priority: number) {2276 return this.helper.executeExtrinsic(2277 signer,2278 'api.tx.scheduler.changeNamedPriority',2279 [scheduledId, priority],2280 true,2281 );2282 }22832284 scheduleAt<T extends UniqueHelper>(2285 scheduledId: string,2286 executionBlockNumber: number,2287 options: ISchedulerOptions = {},2288 ) {2289 return this.schedule<T>('scheduleNamed', scheduledId, executionBlockNumber, options);2290 }22912292 scheduleAfter<T extends UniqueHelper>(2293 scheduledId: string,2294 blocksBeforeExecution: number,2295 options: ISchedulerOptions = {},2296 ) {2297 return this.schedule<T>('scheduleNamedAfter', scheduledId, blocksBeforeExecution, options);2298 }22992300 schedule<T extends UniqueHelper>(2301 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter',2302 scheduledId: string,2303 blocksNum: number,2304 options: ISchedulerOptions = {},2305 ) {2306 // eslint-disable-next-line @typescript-eslint/naming-convention2307 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2308 return this.helper.clone(ScheduledHelperType, {2309 scheduleFn,2310 scheduledId,2311 blocksNum,2312 options,2313 }) as T;2314 }2315}23162317class ForeignAssetsGroup extends HelperGroup {2318 constructor(helper: UniqueHelper) {2319 super(helper);2320 }23212322 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2323 await this.helper.executeExtrinsic(2324 signer,2325 'api.tx.foreignAssets.registerForeignAsset',2326 [ownerAddress, location, metadata],2327 true,2328 );2329 }23302331 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2332 await this.helper.executeExtrinsic(2333 signer,2334 'api.tx.foreignAssets.updateForeignAsset',2335 [foreignAssetId, location, metadata],2336 true,2337 );2338 }2339}23402341export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;23422343export class UniqueHelper extends ChainHelperBase {2344 helperBase: any;23452346 chain: ChainGroup;2347 balance: BalanceGroup;2348 address: AddressGroup;2349 collection: CollectionGroup;2350 nft: NFTGroup;2351 rft: RFTGroup;2352 ft: FTGroup;2353 staking: StakingGroup;2354 scheduler: SchedulerGroup;2355 foreignAssets: ForeignAssetsGroup;23562357 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2358 super(logger);23592360 this.helperBase = options.helperBase ?? UniqueHelper;23612362 this.chain = new ChainGroup(this);2363 this.balance = new BalanceGroup(this);2364 this.address = new AddressGroup(this);2365 this.collection = new CollectionGroup(this);2366 this.nft = new NFTGroup(this);2367 this.rft = new RFTGroup(this);2368 this.ft = new FTGroup(this);2369 this.staking = new StakingGroup(this);2370 this.scheduler = new SchedulerGroup(this);2371 this.foreignAssets = new ForeignAssetsGroup(this);2372 }23732374 clone(helperCls: UniqueHelperConstructor, options: {[key: string]: any} = {}) {2375 Object.setPrototypeOf(helperCls.prototype, this);2376 const newHelper = new helperCls(this.logger, options);23772378 newHelper.api = this.api;2379 newHelper.network = this.network;2380 newHelper.forceNetwork = this.forceNetwork;23812382 this.children.push(newHelper);23832384 return newHelper;2385 }23862387 getSudo<T extends UniqueHelper>() {2388 // eslint-disable-next-line @typescript-eslint/naming-convention2389 const SudoHelperType = SudoUniqueHelper(this.helperBase);2390 return this.clone(SudoHelperType) as T;2391 }2392}23932394// eslint-disable-next-line @typescript-eslint/naming-convention2395function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {2396 return class extends Base {2397 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter';2398 scheduledId: string;2399 blocksNum: number;2400 options: ISchedulerOptions;24012402 constructor(...args: any[]) {2403 const logger = args[0] as ILogger;2404 const options = args[1] as {2405 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter',2406 scheduledId: string,2407 blocksNum: number,2408 options: ISchedulerOptions2409 };24102411 super(logger);24122413 this.scheduleFn = options.scheduleFn;2414 this.scheduledId = options.scheduledId;2415 this.blocksNum = options.blocksNum;2416 this.options = options.options;2417 }24182419 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {2420 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);2421 const extrinsic = 'api.tx.scheduler.' + this.scheduleFn;24222423 return super.executeExtrinsic(2424 sender,2425 extrinsic,2426 [2427 this.scheduledId,2428 this.blocksNum,2429 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,2430 this.options.priority ?? null,2431 {Value: scheduledTx},2432 ],2433 expectSuccess,2434 );2435 }2436 };2437}24382439// eslint-disable-next-line @typescript-eslint/naming-convention2440function SudoUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {2441 return class extends Base {2442 constructor(...args: any[]) {2443 super(...args);2444 }24452446 executeExtrinsic (2447 sender: IKeyringPair,2448 extrinsic: string,2449 params: any[],2450 expectSuccess?: boolean,2451 ): Promise<ITransactionResult> {2452 const call = this.constructApiCall(extrinsic, params);24532454 return super.executeExtrinsic(2455 sender,2456 'api.tx.sudo.sudo',2457 [call],2458 expectSuccess,2459 );2460 }2461 };2462}24632464export class UniqueBaseCollection {2465 helper: UniqueHelper;2466 collectionId: number;24672468 constructor(collectionId: number, uniqueHelper: UniqueHelper) {2469 this.collectionId = collectionId;2470 this.helper = uniqueHelper;2471 }24722473 async getData() {2474 return await this.helper.collection.getData(this.collectionId);2475 }24762477 async getLastTokenId() {2478 return await this.helper.collection.getLastTokenId(this.collectionId);2479 }24802481 async doesTokenExist(tokenId: number) {2482 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);2483 }24842485 async getAdmins() {2486 return await this.helper.collection.getAdmins(this.collectionId);2487 }24882489 async getAllowList() {2490 return await this.helper.collection.getAllowList(this.collectionId);2491 }24922493 async getEffectiveLimits() {2494 return await this.helper.collection.getEffectiveLimits(this.collectionId);2495 }24962497 async getProperties(propertyKeys?: string[] | null) {2498 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);2499 }25002501 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {2502 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);2503 }25042505 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {2506 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);2507 }25082509 async confirmSponsorship(signer: TSigner) {2510 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);2511 }25122513 async removeSponsor(signer: TSigner) {2514 return await this.helper.collection.removeSponsor(signer, this.collectionId);2515 }25162517 async setLimits(signer: TSigner, limits: ICollectionLimits) {2518 return await this.helper.collection.setLimits(signer, this.collectionId, limits);2519 }25202521 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {2522 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);2523 }25242525 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2526 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);2527 }25282529 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {2530 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);2531 }25322533 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {2534 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);2535 }25362537 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2538 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);2539 }25402541 async setProperties(signer: TSigner, properties: IProperty[]) {2542 return await this.helper.collection.setProperties(signer, this.collectionId, properties);2543 }25442545 async deleteProperties(signer: TSigner, propertyKeys: string[]) {2546 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);2547 }25482549 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {2550 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);2551 }25522553 async enableNesting(signer: TSigner, permissions: INestingPermissions) {2554 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);2555 }25562557 async disableNesting(signer: TSigner) {2558 return await this.helper.collection.disableNesting(signer, this.collectionId);2559 }25602561 async burn(signer: TSigner) {2562 return await this.helper.collection.burn(signer, this.collectionId);2563 }25642565 scheduleAt<T extends UniqueHelper>(2566 scheduledId: string,2567 executionBlockNumber: number,2568 options: ISchedulerOptions = {},2569 ) {2570 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);2571 return new UniqueBaseCollection(this.collectionId, scheduledHelper);2572 }25732574 scheduleAfter<T extends UniqueHelper>(2575 scheduledId: string,2576 blocksBeforeExecution: number,2577 options: ISchedulerOptions = {},2578 ) {2579 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);2580 return new UniqueBaseCollection(this.collectionId, scheduledHelper);2581 }25822583 getSudo<T extends UniqueHelper>() {2584 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());2585 }2586}258725882589export class UniqueNFTCollection extends UniqueBaseCollection {2590 getTokenObject(tokenId: number) {2591 return new UniqueNFToken(tokenId, this);2592 }25932594 async getTokensByAddress(addressObj: ICrossAccountId) {2595 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);2596 }25972598 async getToken(tokenId: number, blockHashAt?: string) {2599 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);2600 }26012602 async getTokenOwner(tokenId: number, blockHashAt?: string) {2603 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);2604 }26052606 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {2607 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);2608 }26092610 async getTokenChildren(tokenId: number, blockHashAt?: string) {2611 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);2612 }26132614 async getPropertyPermissions(propertyKeys: string[] | null = null) {2615 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);2616 }26172618 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {2619 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);2620 }26212622 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {2623 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);2624 }26252626 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2627 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);2628 }26292630 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {2631 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);2632 }26332634 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {2635 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);2636 }26372638 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {2639 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});2640 }26412642 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {2643 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);2644 }26452646 async burnToken(signer: TSigner, tokenId: number) {2647 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);2648 }26492650 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {2651 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);2652 }26532654 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {2655 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);2656 }26572658 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {2659 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);2660 }26612662 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {2663 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);2664 }26652666 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {2667 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);2668 }26692670 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {2671 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);2672 }26732674 scheduleAt<T extends UniqueHelper>(2675 scheduledId: string,2676 executionBlockNumber: number,2677 options: ISchedulerOptions = {},2678 ) {2679 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);2680 return new UniqueNFTCollection(this.collectionId, scheduledHelper);2681 }26822683 scheduleAfter<T extends UniqueHelper>(2684 scheduledId: string,2685 blocksBeforeExecution: number,2686 options: ISchedulerOptions = {},2687 ) {2688 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);2689 return new UniqueNFTCollection(this.collectionId, scheduledHelper);2690 }26912692 getSudo<T extends UniqueHelper>() {2693 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());2694 }2695}269626972698export class UniqueRFTCollection extends UniqueBaseCollection {2699 getTokenObject(tokenId: number) {2700 return new UniqueRFToken(tokenId, this);2701 }27022703 async getToken(tokenId: number, blockHashAt?: string) {2704 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);2705 }27062707 async getTokensByAddress(addressObj: ICrossAccountId) {2708 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);2709 }27102711 async getTop10TokenOwners(tokenId: number) {2712 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);2713 }27142715 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {2716 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);2717 }27182719 async getTokenTotalPieces(tokenId: number) {2720 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);2721 }27222723 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2724 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);2725 }27262727 async getPropertyPermissions(propertyKeys: string[] | null = null) {2728 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);2729 }27302731 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {2732 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);2733 }27342735 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {2736 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);2737 }27382739 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2740 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);2741 }27422743 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {2744 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);2745 }27462747 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {2748 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);2749 }27502751 async mintToken(signer: TSigner, pieces=1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {2752 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});2753 }27542755 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {2756 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);2757 }27582759 async burnToken(signer: TSigner, tokenId: number, amount=1n) {2760 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);2761 }27622763 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {2764 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);2765 }27662767 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {2768 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);2769 }27702771 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {2772 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);2773 }27742775 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {2776 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);2777 }27782779 scheduleAt<T extends UniqueHelper>(2780 scheduledId: string,2781 executionBlockNumber: number,2782 options: ISchedulerOptions = {},2783 ) {2784 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);2785 return new UniqueRFTCollection(this.collectionId, scheduledHelper);2786 }27872788 scheduleAfter<T extends UniqueHelper>(2789 scheduledId: string,2790 blocksBeforeExecution: number,2791 options: ISchedulerOptions = {},2792 ) {2793 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);2794 return new UniqueRFTCollection(this.collectionId, scheduledHelper);2795 }27962797 getSudo<T extends UniqueHelper>() {2798 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());2799 }2800}280128022803export class UniqueFTCollection extends UniqueBaseCollection {2804 async getBalance(addressObj: ICrossAccountId) {2805 return await this.helper.ft.getBalance(this.collectionId, addressObj);2806 }28072808 async getTotalPieces() {2809 return await this.helper.ft.getTotalPieces(this.collectionId);2810 }28112812 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2813 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);2814 }28152816 async getTop10Owners() {2817 return await this.helper.ft.getTop10Owners(this.collectionId);2818 }28192820 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {2821 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);2822 }28232824 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {2825 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);2826 }28272828 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {2829 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);2830 }28312832 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2833 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);2834 }28352836 async burnTokens(signer: TSigner, amount=1n) {2837 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);2838 }28392840 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {2841 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);2842 }28432844 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {2845 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);2846 }28472848 scheduleAt<T extends UniqueHelper>(2849 scheduledId: string,2850 executionBlockNumber: number,2851 options: ISchedulerOptions = {},2852 ) {2853 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);2854 return new UniqueFTCollection(this.collectionId, scheduledHelper);2855 }28562857 scheduleAfter<T extends UniqueHelper>(2858 scheduledId: string,2859 blocksBeforeExecution: number,2860 options: ISchedulerOptions = {},2861 ) {2862 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);2863 return new UniqueFTCollection(this.collectionId, scheduledHelper);2864 }28652866 getSudo<T extends UniqueHelper>() {2867 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());2868 }2869}287028712872export class UniqueBaseToken {2873 collection: UniqueNFTCollection | UniqueRFTCollection;2874 collectionId: number;2875 tokenId: number;28762877 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {2878 this.collection = collection;2879 this.collectionId = collection.collectionId;2880 this.tokenId = tokenId;2881 }28822883 async getNextSponsored(addressObj: ICrossAccountId) {2884 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);2885 }28862887 async getProperties(propertyKeys?: string[] | null) {2888 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);2889 }28902891 async setProperties(signer: TSigner, properties: IProperty[]) {2892 return await this.collection.setTokenProperties(signer, this.tokenId, properties);2893 }28942895 async deleteProperties(signer: TSigner, propertyKeys: string[]) {2896 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);2897 }28982899 async doesExist() {2900 return await this.collection.doesTokenExist(this.tokenId);2901 }29022903 nestingAccount() {2904 return this.collection.helper.util.getTokenAccount(this);2905 }29062907 scheduleAt<T extends UniqueHelper>(2908 scheduledId: string,2909 executionBlockNumber: number,2910 options: ISchedulerOptions = {},2911 ) {2912 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);2913 return new UniqueBaseToken(this.tokenId, scheduledCollection);2914 }29152916 scheduleAfter<T extends UniqueHelper>(2917 scheduledId: string,2918 blocksBeforeExecution: number,2919 options: ISchedulerOptions = {},2920 ) {2921 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);2922 return new UniqueBaseToken(this.tokenId, scheduledCollection);2923 }29242925 getSudo<T extends UniqueHelper>() {2926 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());2927 }2928}292929302931export class UniqueNFToken extends UniqueBaseToken {2932 collection: UniqueNFTCollection;29332934 constructor(tokenId: number, collection: UniqueNFTCollection) {2935 super(tokenId, collection);2936 this.collection = collection;2937 }29382939 async getData(blockHashAt?: string) {2940 return await this.collection.getToken(this.tokenId, blockHashAt);2941 }29422943 async getOwner(blockHashAt?: string) {2944 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);2945 }29462947 async getTopmostOwner(blockHashAt?: string) {2948 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);2949 }29502951 async getChildren(blockHashAt?: string) {2952 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);2953 }29542955 async nest(signer: TSigner, toTokenObj: IToken) {2956 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);2957 }29582959 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {2960 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);2961 }29622963 async transfer(signer: TSigner, addressObj: ICrossAccountId) {2964 return await this.collection.transferToken(signer, this.tokenId, addressObj);2965 }29662967 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2968 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);2969 }29702971 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {2972 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);2973 }29742975 async isApproved(toAddressObj: ICrossAccountId) {2976 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);2977 }29782979 async burn(signer: TSigner) {2980 return await this.collection.burnToken(signer, this.tokenId);2981 }29822983 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {2984 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);2985 }29862987 scheduleAt<T extends UniqueHelper>(2988 scheduledId: string,2989 executionBlockNumber: number,2990 options: ISchedulerOptions = {},2991 ) {2992 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);2993 return new UniqueNFToken(this.tokenId, scheduledCollection);2994 }29952996 scheduleAfter<T extends UniqueHelper>(2997 scheduledId: string,2998 blocksBeforeExecution: number,2999 options: ISchedulerOptions = {},3000 ) {3001 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3002 return new UniqueNFToken(this.tokenId, scheduledCollection);3003 }30043005 getSudo<T extends UniqueHelper>() {3006 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3007 }3008}30093010export class UniqueRFToken extends UniqueBaseToken {3011 collection: UniqueRFTCollection;30123013 constructor(tokenId: number, collection: UniqueRFTCollection) {3014 super(tokenId, collection);3015 this.collection = collection;3016 }30173018 async getData(blockHashAt?: string) {3019 return await this.collection.getToken(this.tokenId, blockHashAt);3020 }30213022 async getTop10Owners() {3023 return await this.collection.getTop10TokenOwners(this.tokenId);3024 }30253026 async getBalance(addressObj: ICrossAccountId) {3027 return await this.collection.getTokenBalance(this.tokenId, addressObj);3028 }30293030 async getTotalPieces() {3031 return await this.collection.getTokenTotalPieces(this.tokenId);3032 }30333034 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {3035 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);3036 }30373038 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {3039 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);3040 }30413042 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3043 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);3044 }30453046 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3047 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);3048 }30493050 async repartition(signer: TSigner, amount: bigint) {3051 return await this.collection.repartitionToken(signer, this.tokenId, amount);3052 }30533054 async burn(signer: TSigner, amount=1n) {3055 return await this.collection.burnToken(signer, this.tokenId, amount);3056 }30573058 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3059 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);3060 }30613062 scheduleAt<T extends UniqueHelper>(3063 scheduledId: string,3064 executionBlockNumber: number,3065 options: ISchedulerOptions = {},3066 ) {3067 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);3068 return new UniqueRFToken(this.tokenId, scheduledCollection);3069 }30703071 scheduleAfter<T extends UniqueHelper>(3072 scheduledId: string,3073 blocksBeforeExecution: number,3074 options: ISchedulerOptions = {},3075 ) {3076 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3077 return new UniqueRFToken(this.tokenId, scheduledCollection);3078 }30793080 getSudo<T extends UniqueHelper>() {3081 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());3082 }3083}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} from '@polkadot/util-crypto';11import {IKeyringPair} from '@polkadot/types/types';12import {IApiListeners, IBlock, IEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, IStakingInfo, ISchedulerOptions, ISubstrateBalance, IToken, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, IForeignAssetMetadata, TNetworks, MoonbeamAssetInfo, DemocracyStandardAccountVote, AcalaAssetMetadata} from './types';1314export class CrossAccountId implements ICrossAccountId {15 Substrate?: TSubstrateAccount;16 Ethereum?: TEthereumAccount;1718 constructor(account: ICrossAccountId) {19 if (account.Substrate) this.Substrate = account.Substrate;20 if (account.Ethereum) this.Ethereum = account.Ethereum;21 }2223 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {24 switch (domain) {25 case 'Substrate': return new CrossAccountId({Substrate: account.address});26 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();27 }28 }2930 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {31 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});32 }3334 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {35 return encodeAddress(decodeAddress(address), ss58Format);36 }3738 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {39 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});40 }41 42 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {43 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);44 return this;45 }4647 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {48 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));49 }5051 toEthereum(): CrossAccountId {52 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});53 return this;54 }5556 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {57 return evmToAddress(address, ss58Format);58 }5960 toSubstrate(ss58Format?: number): CrossAccountId {61 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});62 return this;63 }64 65 toLowerCase(): CrossAccountId {66 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();67 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();68 return this;69 }70}7172const nesting = {73 toChecksumAddress(address: string): string {74 if (typeof address === 'undefined') return '';7576 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);7778 address = address.toLowerCase().replace(/^0x/i,'');79 const addressHash = keccakAsHex(address).replace(/^0x/i,'');80 const checksumAddress = ['0x'];8182 for (let i = 0; i < address.length; i++) {83 // If ith character is 8 to f then make it uppercase84 if (parseInt(addressHash[i], 16) > 7) {85 checksumAddress.push(address[i].toUpperCase());86 } else {87 checksumAddress.push(address[i]);88 }89 }90 return checksumAddress.join('');91 },92 tokenIdToAddress(collectionId: number, tokenId: number) {93 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8,'0')}${tokenId.toString(16).padStart(8,'0')}`);94 },95};9697class UniqueUtil {98 static transactionStatus = {99 NOT_READY: 'NotReady',100 FAIL: 'Fail',101 SUCCESS: 'Success',102 };103104 static chainLogType = {105 EXTRINSIC: 'extrinsic',106 RPC: 'rpc',107 };108109 static getTokenAccount(token: IToken): CrossAccountId {110 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});111 }112113 static getTokenAddress(token: IToken): string {114 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);115 }116117 static getDefaultLogger(): ILogger {118 return {119 log(msg: any, level = 'INFO') {120 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));121 },122 level: {123 ERROR: 'ERROR',124 WARNING: 'WARNING',125 INFO: 'INFO',126 },127 };128 }129130 static vec2str(arr: string[] | number[]) {131 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');132 }133134 static str2vec(string: string) {135 if (typeof string !== 'string') return string;136 return Array.from(string).map(x => x.charCodeAt(0));137 }138139 static fromSeed(seed: string, ss58Format = 42) {140 const keyring = new Keyring({type: 'sr25519', ss58Format});141 return keyring.addFromUri(seed);142 }143144 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {145 if (creationResult.status !== this.transactionStatus.SUCCESS) {146 throw Error('Unable to create collection!');147 }148149 let collectionId = null;150 creationResult.result.events.forEach(({event: {data, method, section}}) => {151 if ((section === 'common') && (method === 'CollectionCreated')) {152 collectionId = parseInt(data[0].toString(), 10);153 }154 });155156 if (collectionId === null) {157 throw Error('No CollectionCreated event was found!');158 }159160 return collectionId;161 }162163 static extractTokensFromCreationResult(creationResult: ITransactionResult): {164 success: boolean, 165 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],166 } {167 if (creationResult.status !== this.transactionStatus.SUCCESS) {168 throw Error('Unable to create tokens!');169 }170 let success = false;171 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];172 creationResult.result.events.forEach(({event: {data, method, section}}) => {173 if (method === 'ExtrinsicSuccess') {174 success = true;175 } else if ((section === 'common') && (method === 'ItemCreated')) {176 tokens.push({177 collectionId: parseInt(data[0].toString(), 10),178 tokenId: parseInt(data[1].toString(), 10),179 owner: data[2].toHuman(),180 amount: data[3].toBigInt(),181 });182 }183 });184 return {success, tokens};185 }186187 static extractTokensFromBurnResult(burnResult: ITransactionResult): {188 success: boolean, 189 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],190 } {191 if (burnResult.status !== this.transactionStatus.SUCCESS) {192 throw Error('Unable to burn tokens!');193 }194 let success = false;195 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];196 burnResult.result.events.forEach(({event: {data, method, section}}) => {197 if (method === 'ExtrinsicSuccess') {198 success = true;199 } else if ((section === 'common') && (method === 'ItemDestroyed')) {200 tokens.push({201 collectionId: parseInt(data[0].toString(), 10),202 tokenId: parseInt(data[1].toString(), 10),203 owner: data[2].toHuman(),204 amount: data[3].toBigInt(),205 });206 }207 });208 return {success, tokens};209 }210211 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {212 let eventId = null;213 events.forEach(({event: {data, method, section}}) => {214 if ((section === expectedSection) && (method === expectedMethod)) {215 eventId = parseInt(data[0].toString(), 10);216 }217 });218219 if (eventId === null) {220 throw Error(`No ${expectedMethod} event was found!`);221 }222 return eventId === collectionId;223 }224225 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {226 const normalizeAddress = (address: string | ICrossAccountId) => {227 if(typeof address === 'string') return address;228 const obj = {} as any;229 Object.keys(address).forEach(k => {230 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];231 });232 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);233 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();234 return address;235 };236 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;237 events.forEach(({event: {data, method, section}}) => {238 if ((section === 'common') && (method === 'Transfer')) {239 const hData = (data as any).toJSON();240 transfer = {241 collectionId: hData[0],242 tokenId: hData[1],243 from: normalizeAddress(hData[2]),244 to: normalizeAddress(hData[3]),245 amount: BigInt(hData[4]),246 };247 }248 });249 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;250 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);251 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);252 isSuccess = isSuccess && amount === transfer.amount;253 return isSuccess;254 }255}256257class UniqueEventHelper {258 private static extractIndex(index: any): [number, number] | string {259 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];260 return index.toJSON();261 }262263 private static extractSub(data: any, subTypes: any): {[key: string]: any} {264 let obj: any = {};265 let index = 0;266267 if (data.entries) {268 for(const [key, value] of data.entries()) {269 obj[key] = this.extractData(value, subTypes[index]);270 index++;271 }272 } else obj = data.toJSON();273274 return obj;275 }276 277 private static extractData(data: any, type: any): any {278 if(!type) return data.toHuman();279 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();280 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();281 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);282 return data.toHuman();283 }284285 public static extractEvents(records: ITransactionResult): IEvent[] {286 const parsedEvents: IEvent[] = [];287288 records.result.events.forEach((record) => {289 const {event, phase} = record;290 const types = (event as any).typeDef;291292 const eventData: IEvent = {293 section: event.section.toString(),294 method: event.method.toString(),295 index: this.extractIndex(event.index),296 data: [],297 phase: phase.toJSON(),298 };299300 event.data.forEach((val: any, index: number) => {301 eventData.data.push(this.extractData(val, types[index]));302 });303304 parsedEvents.push(eventData);305 });306307 return parsedEvents;308 }309}310311export class ChainHelperBase {312 helperBase: any;313314 transactionStatus = UniqueUtil.transactionStatus;315 chainLogType = UniqueUtil.chainLogType;316 util: typeof UniqueUtil;317 eventHelper: typeof UniqueEventHelper;318 logger: ILogger;319 api: ApiPromise | null;320 forcedNetwork: TNetworks | null;321 network: TNetworks | null;322 chainLog: IUniqueHelperLog[];323 children: ChainHelperBase[];324 address: AddressGroup;325 chain: ChainGroup;326327 constructor(logger?: ILogger, helperBase?: any) {328 this.helperBase = helperBase;329330 this.util = UniqueUtil;331 this.eventHelper = UniqueEventHelper;332 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();333 this.logger = logger;334 this.api = null;335 this.forcedNetwork = null;336 this.network = null;337 this.chainLog = [];338 this.children = [];339 this.address = new AddressGroup(this);340 this.chain = new ChainGroup(this);341 }342343 clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {344 Object.setPrototypeOf(helperCls.prototype, this);345 const newHelper = new helperCls(this.logger, options);346347 newHelper.api = this.api;348 newHelper.network = this.network;349 newHelper.forceNetwork = this.forceNetwork;350351 this.children.push(newHelper);352353 return newHelper;354 }355356 getApi(): ApiPromise {357 if(this.api === null) throw Error('API not initialized');358 return this.api;359 }360361 clearChainLog(): void {362 this.chainLog = [];363 }364365 forceNetwork(value: TNetworks): void {366 this.forcedNetwork = value;367 }368369 async connect(wsEndpoint: string, listeners?: IApiListeners) {370 if (this.api !== null) throw Error('Already connected');371 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);372 this.api = api;373 this.network = network;374 }375376 async disconnect() {377 for (const child of this.children) {378 child.clearApi();379 }380381 if (this.api === null) return;382 await this.api.disconnect();383 this.clearApi();384 }385386 clearApi() {387 this.api = null;388 this.network = null;389 }390391 static async detectNetwork(api: ApiPromise): Promise<TNetworks> {392 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;393 const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];394395 if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;396397 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;398 return 'opal';399 }400401 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {402 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});403 await api.isReady;404405 const network = await this.detectNetwork(api);406407 await api.disconnect();408409 return network;410 }411412 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{413 api: ApiPromise;414 network: TNetworks;415 }> {416 console.log('createConnection network = ', network);417 if(typeof network === 'undefined' || network === null) network = 'opal';418 const supportedRPC = {419 opal: {420 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,421 },422 quartz: {423 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,424 },425 unique: {426 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,427 },428 rococo: {},429 westend: {},430 moonbeam: {},431 moonriver: {},432 acala: {},433 karura: {},434 westmint: {},435 };436 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);437 const rpc = supportedRPC[network];438439 // TODO: investigate how to replace rpc in runtime440 // api._rpcCore.addUserInterfaces(rpc);441442 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});443444 await api.isReadyOrError;445446 if (typeof listeners === 'undefined') listeners = {};447 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {448 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;449 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);450 }451452 return {api, network};453 }454455 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {456 const {events, status} = data;457 if (status.isReady) {458 return this.transactionStatus.NOT_READY;459 }460 if (status.isBroadcast) {461 return this.transactionStatus.NOT_READY;462 }463 if (status.isInBlock || status.isFinalized) {464 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');465 if (errors.length > 0) {466 return this.transactionStatus.FAIL;467 }468 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {469 return this.transactionStatus.SUCCESS;470 }471 }472473 return this.transactionStatus.FAIL;474 }475476 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {477 const sign = (callback: any) => {478 if(options !== null) return transaction.signAndSend(sender, options, callback);479 return transaction.signAndSend(sender, callback);480 };481 // eslint-disable-next-line no-async-promise-executor482 return new Promise(async (resolve, reject) => {483 try {484 const unsub = await sign((result: any) => {485 const status = this.getTransactionStatus(result);486487 if (status === this.transactionStatus.SUCCESS) {488 this.logger.log(`${label} successful`);489 unsub();490 resolve({result, status});491 } else if (status === this.transactionStatus.FAIL) {492 let moduleError = null;493494 if (result.hasOwnProperty('dispatchError')) {495 const dispatchError = result['dispatchError'];496497 if (dispatchError) {498 if (dispatchError.isModule) {499 const modErr = dispatchError.asModule;500 const errorMeta = dispatchError.registry.findMetaError(modErr);501502 moduleError = `${errorMeta.section}.${errorMeta.name}`;503 } else {504 moduleError = dispatchError.toHuman();505 }506 } else {507 this.logger.log(result, this.logger.level.ERROR);508 }509 }510511 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);512 unsub();513 reject({status, moduleError, result});514 }515 });516 } catch (e) {517 this.logger.log(e, this.logger.level.ERROR);518 reject(e);519 }520 });521 }522523 constructApiCall(apiCall: string, params: any[]) {524 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);525 let call = this.getApi() as any;526 for(const part of apiCall.slice(4).split('.')) {527 call = call[part];528 }529 return call(...params);530 }531532 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {533 if(this.api === null) throw Error('API not initialized');534 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);535536 const startTime = (new Date()).getTime();537 let result: ITransactionResult;538 let events: IEvent[] = [];539 try {540 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;541 events = this.eventHelper.extractEvents(result);542 }543 catch(e) {544 if(!(e as object).hasOwnProperty('status')) throw e;545 result = e as ITransactionResult;546 }547548 const endTime = (new Date()).getTime();549550 const log = {551 executedAt: endTime,552 executionTime: endTime - startTime,553 type: this.chainLogType.EXTRINSIC,554 status: result.status,555 call: extrinsic,556 signer: this.getSignerAddress(sender),557 params,558 } as IUniqueHelperLog;559560 if(result.status !== this.transactionStatus.SUCCESS) {561 if (result.moduleError) log.moduleError = result.moduleError;562 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;563 }564 if(events.length > 0) log.events = events;565566 this.chainLog.push(log);567568 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {569 if (result.moduleError) throw Error(`${result.moduleError}`);570 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));571 }572 return result;573 }574575 async callRpc(rpc: string, params?: any[]) {576 if(typeof params === 'undefined') params = [];577 if(this.api === null) throw Error('API not initialized');578 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);579580 const startTime = (new Date()).getTime();581 let result;582 let error = null;583 const log = {584 type: this.chainLogType.RPC,585 call: rpc,586 params,587 } as IUniqueHelperLog;588589 try {590 result = await this.constructApiCall(rpc, params);591 }592 catch(e) {593 error = e;594 }595596 const endTime = (new Date()).getTime();597598 log.executedAt = endTime;599 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';600 log.executionTime = endTime - startTime;601602 this.chainLog.push(log);603604 if(error !== null) throw error;605606 return result;607 }608609 getSignerAddress(signer: IKeyringPair | string): string {610 if(typeof signer === 'string') return signer;611 return signer.address;612 }613614 fetchAllPalletNames(): string[] {615 if(this.api === null) throw Error('API not initialized');616 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());617 }618619 fetchMissingPalletNames(requiredPallets: string[]): string[] {620 const palletNames = this.fetchAllPalletNames();621 return requiredPallets.filter(p => !palletNames.includes(p));622 }623}624625626class HelperGroup<T extends ChainHelperBase> {627 helper: T;628629 constructor(uniqueHelper: T) {630 this.helper = uniqueHelper;631 }632}633634635class CollectionGroup extends HelperGroup<UniqueHelper> {636 /**637 * Get number of blocks when sponsored transaction is available.638 *639 * @param collectionId ID of collection640 * @param tokenId ID of token641 * @param addressObj address for which the sponsorship is checked642 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});643 * @returns number of blocks or null if sponsorship hasn't been set644 */645 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {646 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();647 }648649 /**650 * Get the number of created collections.651 *652 * @returns number of created collections653 */654 async getTotalCount(): Promise<number> {655 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();656 }657658 /**659 * Get information about the collection with additional data,660 * including the number of tokens it contains, its administrators,661 * the normalized address of the collection's owner, and decoded name and description.662 *663 * @param collectionId ID of collection664 * @example await getData(2)665 * @returns collection information object666 */667 async getData(collectionId: number): Promise<{668 id: number;669 name: string;670 description: string;671 tokensCount: number;672 admins: CrossAccountId[];673 normalizedOwner: TSubstrateAccount;674 raw: any675 } | null> {676 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);677 const humanCollection = collection.toHuman(), collectionData = {678 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],679 raw: humanCollection,680 } as any, jsonCollection = collection.toJSON();681 if (humanCollection === null) return null;682 collectionData.raw.limits = jsonCollection.limits;683 collectionData.raw.permissions = jsonCollection.permissions;684 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);685 for (const key of ['name', 'description']) {686 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);687 }688689 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))690 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)691 : 0;692 collectionData.admins = await this.getAdmins(collectionId);693694 return collectionData;695 }696697 /**698 * Get the addresses of the collection's administrators, optionally normalized.699 *700 * @param collectionId ID of collection701 * @param normalize whether to normalize the addresses to the default ss58 format702 * @example await getAdmins(1)703 * @returns array of administrators704 */705 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {706 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();707708 return normalize709 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())710 : admins;711 }712713 /**714 * Get the addresses added to the collection allow-list, optionally normalized.715 * @param collectionId ID of collection716 * @param normalize whether to normalize the addresses to the default ss58 format717 * @example await getAllowList(1)718 * @returns array of allow-listed addresses719 */720 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {721 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();722 return normalize723 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())724 : allowListed;725 }726727 /**728 * Get the effective limits of the collection instead of null for default values729 *730 * @param collectionId ID of collection731 * @example await getEffectiveLimits(2)732 * @returns object of collection limits733 */734 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {735 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();736 }737738 /**739 * Burns the collection if the signer has sufficient permissions and collection is empty.740 *741 * @param signer keyring of signer742 * @param collectionId ID of collection743 * @example await helper.collection.burn(aliceKeyring, 3);744 * @returns ```true``` if extrinsic success, otherwise ```false```745 */746 async burn(signer: TSigner, collectionId: number): Promise<boolean> {747 const result = await this.helper.executeExtrinsic(748 signer,749 'api.tx.unique.destroyCollection', [collectionId],750 true,751 );752753 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');754 }755756 /**757 * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.758 *759 * @param signer keyring of signer760 * @param collectionId ID of collection761 * @param sponsorAddress Sponsor substrate address762 * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")763 * @returns ```true``` if extrinsic success, otherwise ```false```764 */765 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {766 const result = await this.helper.executeExtrinsic(767 signer,768 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],769 true,770 );771772 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorSet');773 }774775 /**776 * Confirms consent to sponsor the collection on behalf of the signer.777 *778 * @param signer keyring of signer779 * @param collectionId ID of collection780 * @example confirmSponsorship(aliceKeyring, 10)781 * @returns ```true``` if extrinsic success, otherwise ```false```782 */783 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {784 const result = await this.helper.executeExtrinsic(785 signer,786 'api.tx.unique.confirmSponsorship', [collectionId],787 true,788 );789790 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'SponsorshipConfirmed');791 }792793 /**794 * Removes the sponsor of a collection, regardless if it consented or not.795 *796 * @param signer keyring of signer797 * @param collectionId ID of collection798 * @example removeSponsor(aliceKeyring, 10)799 * @returns ```true``` if extrinsic success, otherwise ```false```800 */801 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {802 const result = await this.helper.executeExtrinsic(803 signer,804 'api.tx.unique.removeCollectionSponsor', [collectionId],805 true,806 );807808 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorRemoved');809 }810811 /**812 * Sets the limits of the collection. At least one limit must be specified for a correct call.813 *814 * @param signer keyring of signer815 * @param collectionId ID of collection816 * @param limits collection limits object817 * @example818 * await setLimits(819 * aliceKeyring,820 * 10,821 * {822 * sponsorTransferTimeout: 0,823 * ownerCanDestroy: false824 * }825 * )826 * @returns ```true``` if extrinsic success, otherwise ```false```827 */828 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {829 const result = await this.helper.executeExtrinsic(830 signer,831 'api.tx.unique.setCollectionLimits', [collectionId, limits],832 true,833 );834835 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionLimitSet');836 }837838 /**839 * Changes the owner of the collection to the new Substrate address.840 *841 * @param signer keyring of signer842 * @param collectionId ID of collection843 * @param ownerAddress substrate address of new owner844 * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")845 * @returns ```true``` if extrinsic success, otherwise ```false```846 */847 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {848 const result = await this.helper.executeExtrinsic(849 signer,850 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],851 true,852 );853854 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionOwnedChanged');855 }856857 /**858 * Adds a collection administrator.859 *860 * @param signer keyring of signer861 * @param collectionId ID of collection862 * @param adminAddressObj Administrator address (substrate or ethereum)863 * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})864 * @returns ```true``` if extrinsic success, otherwise ```false```865 */866 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {867 const result = await this.helper.executeExtrinsic(868 signer,869 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],870 true,871 );872873 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminAdded');874 }875876 /**877 * Removes a collection administrator.878 *879 * @param signer keyring of signer880 * @param collectionId ID of collection881 * @param adminAddressObj Administrator address (substrate or ethereum)882 * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})883 * @returns ```true``` if extrinsic success, otherwise ```false```884 */885 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {886 const result = await this.helper.executeExtrinsic(887 signer,888 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],889 true,890 );891892 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminRemoved');893 }894895 /**896 * Check if user is in allow list.897 * 898 * @param collectionId ID of collection899 * @param user Account to check900 * @example await getAdmins(1)901 * @returns is user in allow list902 */903 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {904 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();905 }906907 /**908 * Adds an address to allow list909 * @param signer keyring of signer910 * @param collectionId ID of collection911 * @param addressObj address to add to the allow list912 * @returns ```true``` if extrinsic success, otherwise ```false```913 */914 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {915 const result = await this.helper.executeExtrinsic(916 signer,917 'api.tx.unique.addToAllowList', [collectionId, addressObj],918 true,919 );920921 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressAdded');922 }923924 /**925 * Removes an address from allow list926 *927 * @param signer keyring of signer928 * @param collectionId ID of collection929 * @param addressObj address to remove from the allow list930 * @returns ```true``` if extrinsic success, otherwise ```false```931 */932 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {933 const result = await this.helper.executeExtrinsic(934 signer,935 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],936 true,937 );938939 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressRemoved');940 }941942 /**943 * Sets onchain permissions for selected collection.944 *945 * @param signer keyring of signer946 * @param collectionId ID of collection947 * @param permissions collection permissions object948 * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});949 * @returns ```true``` if extrinsic success, otherwise ```false```950 */951 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {952 const result = await this.helper.executeExtrinsic(953 signer,954 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],955 true,956 );957958 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionPermissionSet');959 }960961 /**962 * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.963 *964 * @param signer keyring of signer965 * @param collectionId ID of collection966 * @param permissions nesting permissions object967 * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});968 * @returns ```true``` if extrinsic success, otherwise ```false```969 */970 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {971 return await this.setPermissions(signer, collectionId, {nesting: permissions});972 }973974 /**975 * Disables nesting for selected collection.976 *977 * @param signer keyring of signer978 * @param collectionId ID of collection979 * @example disableNesting(aliceKeyring, 10);980 * @returns ```true``` if extrinsic success, otherwise ```false```981 */982 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {983 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});984 }985986 /**987 * Sets onchain properties to the collection.988 *989 * @param signer keyring of signer990 * @param collectionId ID of collection991 * @param properties array of property objects992 * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);993 * @returns ```true``` if extrinsic success, otherwise ```false```994 */995 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {996 const result = await this.helper.executeExtrinsic(997 signer,998 'api.tx.unique.setCollectionProperties', [collectionId, properties],999 true,1000 );10011002 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1003 }10041005 /**1006 * Get collection properties.1007 * 1008 * @param collectionId ID of collection1009 * @param propertyKeys optionally filter the returned properties to only these keys1010 * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1011 * @returns array of key-value pairs1012 */1013 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1014 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1015 }10161017 /**1018 * Deletes onchain properties from the collection.1019 *1020 * @param signer keyring of signer1021 * @param collectionId ID of collection1022 * @param propertyKeys array of property keys to delete1023 * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1024 * @returns ```true``` if extrinsic success, otherwise ```false```1025 */1026 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1027 const result = await this.helper.executeExtrinsic(1028 signer,1029 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1030 true,1031 );10321033 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1034 }10351036 /**1037 * Changes the owner of the token.1038 *1039 * @param signer keyring of signer1040 * @param collectionId ID of collection1041 * @param tokenId ID of token1042 * @param addressObj address of a new owner1043 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1044 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1045 * @returns true if the token success, otherwise false1046 */1047 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1048 const result = await this.helper.executeExtrinsic(1049 signer,1050 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1051 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1052 );10531054 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1055 }10561057 /**1058 *1059 * Change ownership of a token(s) on behalf of the owner.1060 *1061 * @param signer keyring of signer1062 * @param collectionId ID of collection1063 * @param tokenId ID of token1064 * @param fromAddressObj address on behalf of which the token will be sent1065 * @param toAddressObj new token owner1066 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1067 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1068 * @returns true if the token success, otherwise false1069 */1070 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1071 const result = await this.helper.executeExtrinsic(1072 signer,1073 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1074 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1075 );1076 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1077 }10781079 /**1080 *1081 * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1082 *1083 * @param signer keyring of signer1084 * @param collectionId ID of collection1085 * @param tokenId ID of token1086 * @param amount amount of tokens to be burned. For NFT must be set to 1n1087 * @example burnToken(aliceKeyring, 10, 5);1088 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1089 */1090 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1091 const burnResult = await this.helper.executeExtrinsic(1092 signer,1093 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1094 true, // `Unable to burn token for ${label}`,1095 );1096 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1097 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1098 return burnedTokens.success;1099 }11001101 /**1102 * Destroys a concrete instance of NFT on behalf of the owner1103 *1104 * @param signer keyring of signer1105 * @param collectionId ID of collection1106 * @param tokenId ID of token1107 * @param fromAddressObj address on behalf of which the token will be burnt1108 * @param amount amount of tokens to be burned. For NFT must be set to 1n1109 * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1110 * @returns ```true``` if extrinsic success, otherwise ```false```1111 */1112 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1113 const burnResult = await this.helper.executeExtrinsic(1114 signer,1115 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1116 true, // `Unable to burn token from for ${label}`,1117 );1118 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1119 return burnedTokens.success && burnedTokens.tokens.length > 0;1120 }11211122 /**1123 * Set, change, or remove approved address to transfer the ownership of the NFT.1124 *1125 * @param signer keyring of signer1126 * @param collectionId ID of collection1127 * @param tokenId ID of token1128 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1129 * @param amount amount of token to be approved. For NFT must be set to 1n1130 * @returns ```true``` if extrinsic success, otherwise ```false```1131 */1132 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1133 const approveResult = await this.helper.executeExtrinsic(1134 signer,1135 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1136 true, // `Unable to approve token for ${label}`,1137 );11381139 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1140 }11411142 /**1143 * Get the amount of token pieces approved to transfer or burn. Normally 0.1144 *1145 * @param collectionId ID of collection1146 * @param tokenId ID of token1147 * @param toAccountObj address which is approved to use token pieces1148 * @param fromAccountObj address which may have allowed the use of its owned tokens1149 * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1150 * @returns number of approved to transfer pieces1151 */1152 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1153 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1154 }11551156 /**1157 * Get the last created token ID in a collection1158 *1159 * @param collectionId ID of collection1160 * @example getLastTokenId(10);1161 * @returns id of the last created token1162 */1163 async getLastTokenId(collectionId: number): Promise<number> {1164 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1165 }11661167 /**1168 * Check if token exists1169 *1170 * @param collectionId ID of collection1171 * @param tokenId ID of token1172 * @example doesTokenExist(10, 20);1173 * @returns true if the token exists, otherwise false1174 */1175 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1176 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1177 }1178}11791180class NFTnRFT extends CollectionGroup {1181 /**1182 * Get tokens owned by account1183 *1184 * @param collectionId ID of collection1185 * @param addressObj tokens owner1186 * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1187 * @returns array of token ids owned by account1188 */1189 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1190 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1191 }11921193 /**1194 * Get token data1195 *1196 * @param collectionId ID of collection1197 * @param tokenId ID of token1198 * @param propertyKeys optionally filter the token properties to only these keys1199 * @param blockHashAt optionally query the data at some block with this hash1200 * @example getToken(10, 5);1201 * @returns human readable token data1202 */1203 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1204 properties: IProperty[];1205 owner: CrossAccountId;1206 normalizedOwner: CrossAccountId;1207 }| null> {1208 let tokenData;1209 if(typeof blockHashAt === 'undefined') {1210 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1211 }1212 else {1213 if(propertyKeys.length == 0) {1214 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1215 if(!collection) return null;1216 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1217 }1218 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1219 }1220 tokenData = tokenData.toHuman();1221 if (tokenData === null || tokenData.owner === null) return null;1222 const owner = {} as any;1223 for (const key of Object.keys(tokenData.owner)) {1224 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate' 1225 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key]) 1226 : tokenData.owner[key];1227 }1228 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1229 return tokenData;1230 }12311232 /**1233 * Set permissions to change token properties1234 *1235 * @param signer keyring of signer1236 * @param collectionId ID of collection1237 * @param permissions permissions to change a property by the collection admin or token owner1238 * @example setTokenPropertyPermissions(1239 * aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1240 * )1241 * @returns true if extrinsic success otherwise false1242 */1243 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1244 const result = await this.helper.executeExtrinsic(1245 signer,1246 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1247 true,1248 );12491250 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1251 }12521253 /**1254 * Get token property permissions.1255 * 1256 * @param collectionId ID of collection1257 * @param propertyKeys optionally filter the returned property permissions to only these keys1258 * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1259 * @returns array of key-permission pairs1260 */1261 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1262 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1263 }12641265 /**1266 * Set token properties1267 *1268 * @param signer keyring of signer1269 * @param collectionId ID of collection1270 * @param tokenId ID of token1271 * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1272 * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1273 * @returns ```true``` if extrinsic success, otherwise ```false```1274 */1275 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1276 const result = await this.helper.executeExtrinsic(1277 signer,1278 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1279 true,1280 );12811282 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1283 }12841285 /**1286 * Get properties, metadata assigned to a token.1287 * 1288 * @param collectionId ID of collection1289 * @param tokenId ID of token1290 * @param propertyKeys optionally filter the returned properties to only these keys1291 * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1292 * @returns array of key-value pairs1293 */1294 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1295 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1296 }12971298 /**1299 * Delete the provided properties of a token1300 * @param signer keyring of signer1301 * @param collectionId ID of collection1302 * @param tokenId ID of token1303 * @param propertyKeys property keys to be deleted1304 * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1305 * @returns ```true``` if extrinsic success, otherwise ```false```1306 */1307 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1308 const result = await this.helper.executeExtrinsic(1309 signer,1310 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1311 true,1312 );13131314 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1315 }13161317 /**1318 * Mint new collection1319 *1320 * @param signer keyring of signer1321 * @param collectionOptions basic collection options and properties1322 * @param mode NFT or RFT type of a collection1323 * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1324 * @returns object of the created collection1325 */1326 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1327 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1328 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1329 for (const key of ['name', 'description', 'tokenPrefix']) {1330 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);1331 }1332 const creationResult = await this.helper.executeExtrinsic(1333 signer,1334 'api.tx.unique.createCollectionEx', [collectionOptions],1335 true, // errorLabel,1336 );1337 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1338 }13391340 getCollectionObject(_collectionId: number): any {1341 return null;1342 }13431344 getTokenObject(_collectionId: number, _tokenId: number): any {1345 return null;1346 }1347}134813491350class NFTGroup extends NFTnRFT {1351 /**1352 * Get collection object1353 * @param collectionId ID of collection1354 * @example getCollectionObject(2);1355 * @returns instance of UniqueNFTCollection1356 */1357 getCollectionObject(collectionId: number): UniqueNFTCollection {1358 return new UniqueNFTCollection(collectionId, this.helper);1359 }13601361 /**1362 * Get token object1363 * @param collectionId ID of collection1364 * @param tokenId ID of token1365 * @example getTokenObject(10, 5);1366 * @returns instance of UniqueNFTToken1367 */1368 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1369 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1370 }13711372 /**1373 * Get token's owner1374 * @param collectionId ID of collection1375 * @param tokenId ID of token1376 * @param blockHashAt optionally query the data at the block with this hash1377 * @example getTokenOwner(10, 5);1378 * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1379 */1380 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1381 let owner;1382 if (typeof blockHashAt === 'undefined') {1383 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1384 } else {1385 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1386 }1387 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1388 }13891390 /**1391 * Is token approved to transfer1392 * @param collectionId ID of collection1393 * @param tokenId ID of token1394 * @param toAccountObj address to be approved1395 * @returns ```true``` if extrinsic success, otherwise ```false```1396 */1397 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1398 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1399 }14001401 /**1402 * Changes the owner of the token.1403 *1404 * @param signer keyring of signer1405 * @param collectionId ID of collection1406 * @param tokenId ID of token1407 * @param addressObj address of a new owner1408 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1409 * @returns ```true``` if extrinsic success, otherwise ```false```1410 */1411 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1412 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1413 }14141415 /**1416 *1417 * Change ownership of a NFT on behalf of the owner.1418 *1419 * @param signer keyring of signer1420 * @param collectionId ID of collection1421 * @param tokenId ID of token1422 * @param fromAddressObj address on behalf of which the token will be sent1423 * @param toAddressObj new token owner1424 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1425 * @returns ```true``` if extrinsic success, otherwise ```false```1426 */1427 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1428 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1429 }14301431 /**1432 * Recursively find the address that owns the token1433 * @param collectionId ID of collection1434 * @param tokenId ID of token1435 * @param blockHashAt1436 * @example getTokenTopmostOwner(10, 5);1437 * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1438 */1439 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1440 let owner;1441 if (typeof blockHashAt === 'undefined') {1442 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1443 } else {1444 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1445 }14461447 if (owner === null) return null;14481449 return owner.toHuman();1450 }14511452 /**1453 * Get tokens nested in the provided token1454 * @param collectionId ID of collection1455 * @param tokenId ID of token1456 * @param blockHashAt optionally query the data at the block with this hash1457 * @example getTokenChildren(10, 5);1458 * @returns tokens whose depth of nesting is <= 51459 */1460 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1461 let children;1462 if(typeof blockHashAt === 'undefined') {1463 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1464 } else {1465 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1466 }14671468 return children.toJSON().map((x: any) => {1469 return {collectionId: x.collection, tokenId: x.token};1470 });1471 }14721473 /**1474 * Nest one token into another1475 * @param signer keyring of signer1476 * @param tokenObj token to be nested1477 * @param rootTokenObj token to be parent1478 * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1479 * @returns ```true``` if extrinsic success, otherwise ```false```1480 */1481 async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1482 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1483 const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1484 if(!result) {1485 throw Error('Unable to nest token!');1486 }1487 return result;1488 }14891490 /**1491 * Remove token from nested state1492 * @param signer keyring of signer1493 * @param tokenObj token to unnest1494 * @param rootTokenObj parent of a token1495 * @param toAddressObj address of a new token owner1496 * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1497 * @returns ```true``` if extrinsic success, otherwise ```false```1498 */1499 async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1500 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1501 const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1502 if(!result) {1503 throw Error('Unable to unnest token!');1504 }1505 return result;1506 }15071508 /**1509 * Mint new collection1510 * @param signer keyring of signer1511 * @param collectionOptions Collection options1512 * @example1513 * mintCollection(aliceKeyring, {1514 * name: 'New',1515 * description: 'New collection',1516 * tokenPrefix: 'NEW',1517 * })1518 * @returns object of the created collection1519 */1520 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1521 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1522 }15231524 /**1525 * Mint new token1526 * @param signer keyring of signer1527 * @param data token data1528 * @returns created token object1529 */1530 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1531 const creationResult = await this.helper.executeExtrinsic(1532 signer,1533 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1534 nft: {1535 properties: data.properties,1536 },1537 }],1538 true,1539 );1540 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1541 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1542 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1543 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1544 }15451546 /**1547 * Mint multiple NFT tokens1548 * @param signer keyring of signer1549 * @param collectionId ID of collection1550 * @param tokens array of tokens with owner and properties1551 * @example1552 * mintMultipleTokens(aliceKeyring, 10, [{1553 * owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1554 * properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1555 * },{1556 * owner: {Ethereum: "0x9F0583DbB855d..."},1557 * properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1558 * }]);1559 * @returns ```true``` if extrinsic success, otherwise ```false```1560 */1561 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1562 const creationResult = await this.helper.executeExtrinsic(1563 signer,1564 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1565 true,1566 );1567 const collection = this.getCollectionObject(collectionId);1568 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1569 }15701571 /**1572 * Mint multiple NFT tokens with one owner1573 * @param signer keyring of signer1574 * @param collectionId ID of collection1575 * @param owner tokens owner1576 * @param tokens array of tokens with owner and properties1577 * @example1578 * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1579 * properties: [{1580 * key: "gender",1581 * value: "female",1582 * },{1583 * key: "age",1584 * value: "33",1585 * }],1586 * }]);1587 * @returns array of newly created tokens1588 */1589 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1590 const rawTokens = [];1591 for (const token of tokens) {1592 const raw = {NFT: {properties: token.properties}};1593 rawTokens.push(raw);1594 }1595 const creationResult = await this.helper.executeExtrinsic(1596 signer,1597 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1598 true,1599 );1600 const collection = this.getCollectionObject(collectionId);1601 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1602 }16031604 /**1605 * Set, change, or remove approved address to transfer the ownership of the NFT.1606 *1607 * @param signer keyring of signer1608 * @param collectionId ID of collection1609 * @param tokenId ID of token1610 * @param toAddressObj address to approve1611 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1612 * @returns ```true``` if extrinsic success, otherwise ```false```1613 */1614 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId) {1615 return super.approveToken(signer, collectionId, tokenId, toAddressObj, 1n);1616 }1617}161816191620class RFTGroup extends NFTnRFT {1621 /**1622 * Get collection object1623 * @param collectionId ID of collection1624 * @example getCollectionObject(2);1625 * @returns instance of UniqueRFTCollection1626 */1627 getCollectionObject(collectionId: number): UniqueRFTCollection {1628 return new UniqueRFTCollection(collectionId, this.helper);1629 }16301631 /**1632 * Get token object1633 * @param collectionId ID of collection1634 * @param tokenId ID of token1635 * @example getTokenObject(10, 5);1636 * @returns instance of UniqueNFTToken1637 */1638 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1639 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1640 }16411642 /**1643 * Get top 10 token owners with the largest number of pieces1644 * @param collectionId ID of collection1645 * @param tokenId ID of token1646 * @example getTokenTop10Owners(10, 5);1647 * @returns array of top 10 owners1648 */1649 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1650 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1651 }16521653 /**1654 * Get number of pieces owned by address1655 * @param collectionId ID of collection1656 * @param tokenId ID of token1657 * @param addressObj address token owner1658 * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1659 * @returns number of pieces ownerd by address1660 */1661 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1662 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1663 }16641665 /**1666 * Transfer pieces of token to another address1667 * @param signer keyring of signer1668 * @param collectionId ID of collection1669 * @param tokenId ID of token1670 * @param addressObj address of a new owner1671 * @param amount number of pieces to be transfered1672 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1673 * @returns ```true``` if extrinsic success, otherwise ```false```1674 */1675 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1676 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1677 }16781679 /**1680 * Change ownership of some pieces of RFT on behalf of the owner.1681 * @param signer keyring of signer1682 * @param collectionId ID of collection1683 * @param tokenId ID of token1684 * @param fromAddressObj address on behalf of which the token will be sent1685 * @param toAddressObj new token owner1686 * @param amount number of pieces to be transfered1687 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1688 * @returns ```true``` if extrinsic success, otherwise ```false```1689 */1690 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1691 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1692 }16931694 /**1695 * Mint new collection1696 * @param signer keyring of signer1697 * @param collectionOptions Collection options1698 * @example1699 * mintCollection(aliceKeyring, {1700 * name: 'New',1701 * description: 'New collection',1702 * tokenPrefix: 'NEW',1703 * })1704 * @returns object of the created collection1705 */1706 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1707 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1708 }17091710 /**1711 * Mint new token1712 * @param signer keyring of signer1713 * @param data token data1714 * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1715 * @returns created token object1716 */1717 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1718 const creationResult = await this.helper.executeExtrinsic(1719 signer,1720 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1721 refungible: {1722 pieces: data.pieces,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 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1735 throw Error('Not implemented');1736 const creationResult = await this.helper.executeExtrinsic(1737 signer,1738 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1739 true, // `Unable to mint RFT tokens for ${label}`,1740 );1741 const collection = this.getCollectionObject(collectionId);1742 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1743 }17441745 /**1746 * Mint multiple RFT tokens with one owner1747 * @param signer keyring of signer1748 * @param collectionId ID of collection1749 * @param owner tokens owner1750 * @param tokens array of tokens with properties and pieces1751 * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1752 * @returns array of newly created RFT tokens1753 */1754 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1755 const rawTokens = [];1756 for (const token of tokens) {1757 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1758 rawTokens.push(raw);1759 }1760 const creationResult = await this.helper.executeExtrinsic(1761 signer,1762 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1763 true,1764 );1765 const collection = this.getCollectionObject(collectionId);1766 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1767 }17681769 /**1770 * Destroys a concrete instance of RFT.1771 * @param signer keyring of signer1772 * @param collectionId ID of collection1773 * @param tokenId ID of token1774 * @param amount number of pieces to be burnt1775 * @example burnToken(aliceKeyring, 10, 5);1776 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1777 */1778 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1779 return await super.burnToken(signer, collectionId, tokenId, amount);1780 }17811782 /**1783 * Destroys a concrete instance of RFT on behalf of the owner.1784 * @param signer keyring of signer1785 * @param collectionId ID of collection1786 * @param tokenId ID of token1787 * @param fromAddressObj address on behalf of which the token will be burnt1788 * @param amount number of pieces to be burnt1789 * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1790 * @returns ```true``` if extrinsic success, otherwise ```false```1791 */1792 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1793 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1794 }17951796 /**1797 * Set, change, or remove approved address to transfer the ownership of the RFT.1798 *1799 * @param signer keyring of signer1800 * @param collectionId ID of collection1801 * @param tokenId ID of token1802 * @param toAddressObj address to approve1803 * @param amount number of pieces to be approved1804 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);1805 * @returns true if the token success, otherwise false1806 */1807 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1808 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1809 }18101811 /**1812 * Get total number of pieces1813 * @param collectionId ID of collection1814 * @param tokenId ID of token1815 * @example getTokenTotalPieces(10, 5);1816 * @returns number of pieces1817 */1818 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {1819 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();1820 }18211822 /**1823 * Change number of token pieces. Signer must be the owner of all token pieces.1824 * @param signer keyring of signer1825 * @param collectionId ID of collection1826 * @param tokenId ID of token1827 * @param amount new number of pieces1828 * @example repartitionToken(aliceKeyring, 10, 5, 12345n);1829 * @returns true if the repartion was success, otherwise false1830 */1831 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {1832 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);1833 const repartitionResult = await this.helper.executeExtrinsic(1834 signer,1835 'api.tx.unique.repartition', [collectionId, tokenId, amount],1836 true,1837 );1838 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');1839 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');1840 }1841}184218431844class FTGroup extends CollectionGroup {1845 /**1846 * Get collection object1847 * @param collectionId ID of collection1848 * @example getCollectionObject(2);1849 * @returns instance of UniqueFTCollection1850 */1851 getCollectionObject(collectionId: number): UniqueFTCollection {1852 return new UniqueFTCollection(collectionId, this.helper);1853 }18541855 /**1856 * Mint new fungible collection1857 * @param signer keyring of signer1858 * @param collectionOptions Collection options1859 * @param decimalPoints number of token decimals1860 * @example1861 * mintCollection(aliceKeyring, {1862 * name: 'New',1863 * description: 'New collection',1864 * tokenPrefix: 'NEW',1865 * }, 18)1866 * @returns newly created fungible collection1867 */1868 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {1869 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1870 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');1871 collectionOptions.mode = {fungible: decimalPoints};1872 for (const key of ['name', 'description', 'tokenPrefix']) {1873 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);1874 }1875 const creationResult = await this.helper.executeExtrinsic(1876 signer,1877 'api.tx.unique.createCollectionEx', [collectionOptions],1878 true,1879 );1880 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1881 }18821883 /**1884 * Mint tokens1885 * @param signer keyring of signer1886 * @param collectionId ID of collection1887 * @param owner address owner of new tokens1888 * @param amount amount of tokens to be meanted1889 * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);1890 * @returns ```true``` if extrinsic success, otherwise ```false```1891 */1892 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {1893 const creationResult = await this.helper.executeExtrinsic(1894 signer,1895 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {1896 fungible: {1897 value: amount,1898 },1899 }],1900 true, // `Unable to mint fungible tokens for ${label}`,1901 );1902 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1903 }19041905 /**1906 * Mint multiple Fungible tokens with one owner1907 * @param signer keyring of signer1908 * @param collectionId ID of collection1909 * @param owner tokens owner1910 * @param tokens array of tokens with properties and pieces1911 * @returns ```true``` if extrinsic success, otherwise ```false```1912 */1913 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {1914 const rawTokens = [];1915 for (const token of tokens) {1916 const raw = {Fungible: {Value: token.value}};1917 rawTokens.push(raw);1918 }1919 const creationResult = await this.helper.executeExtrinsic(1920 signer,1921 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1922 true,1923 );1924 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1925 }19261927 /**1928 * Get the top 10 owners with the largest balance for the Fungible collection1929 * @param collectionId ID of collection1930 * @example getTop10Owners(10);1931 * @returns array of ```ICrossAccountId```1932 */1933 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {1934 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1935 }19361937 /**1938 * Get account balance1939 * @param collectionId ID of collection1940 * @param addressObj address of owner1941 * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})1942 * @returns amount of fungible tokens owned by address1943 */1944 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {1945 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();1946 }19471948 /**1949 * Transfer tokens to address1950 * @param signer keyring of signer1951 * @param collectionId ID of collection1952 * @param toAddressObj address recipient1953 * @param amount amount of tokens to be sent1954 * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);1955 * @returns ```true``` if extrinsic success, otherwise ```false```1956 */1957 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {1958 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);1959 }19601961 /**1962 * Transfer some tokens on behalf of the owner.1963 * @param signer keyring of signer1964 * @param collectionId ID of collection1965 * @param fromAddressObj address on behalf of which tokens will be sent1966 * @param toAddressObj address where token to be sent1967 * @param amount number of tokens to be sent1968 * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);1969 * @returns ```true``` if extrinsic success, otherwise ```false```1970 */1971 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1972 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);1973 }19741975 /**1976 * Destroy some amount of tokens1977 * @param signer keyring of signer1978 * @param collectionId ID of collection1979 * @param amount amount of tokens to be destroyed1980 * @example burnTokens(aliceKeyring, 10, 1000n);1981 * @returns ```true``` if extrinsic success, otherwise ```false```1982 */1983 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {1984 return await super.burnToken(signer, collectionId, 0, amount);1985 }19861987 /**1988 * Burn some tokens on behalf of the owner.1989 * @param signer keyring of signer1990 * @param collectionId ID of collection1991 * @param fromAddressObj address on behalf of which tokens will be burnt1992 * @param amount amount of tokens to be burnt1993 * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);1994 * @returns ```true``` if extrinsic success, otherwise ```false```1995 */1996 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1997 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);1998 }19992000 /**2001 * Get total collection supply2002 * @param collectionId2003 * @returns2004 */2005 async getTotalPieces(collectionId: number): Promise<bigint> {2006 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2007 }20082009 /**2010 * Set, change, or remove approved address to transfer tokens.2011 *2012 * @param signer keyring of signer2013 * @param collectionId ID of collection2014 * @param toAddressObj address to be approved2015 * @param amount amount of tokens to be approved2016 * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2017 * @returns ```true``` if extrinsic success, otherwise ```false```2018 */2019 async approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2020 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2021 }20222023 /**2024 * Get amount of fungible tokens approved to transfer2025 * @param collectionId ID of collection2026 * @param fromAddressObj owner of tokens2027 * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2028 * @returns number of tokens approved for the transfer2029 */2030 async getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2031 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2032 }2033}203420352036class ChainGroup extends HelperGroup<ChainHelperBase> {2037 /**2038 * Get system properties of a chain2039 * @example getChainProperties();2040 * @returns ss58Format, token decimals, and token symbol2041 */2042 getChainProperties(): IChainProperties {2043 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2044 return {2045 ss58Format: properties.ss58Format.toJSON(),2046 tokenDecimals: properties.tokenDecimals.toJSON(),2047 tokenSymbol: properties.tokenSymbol.toJSON(),2048 };2049 }20502051 /**2052 * Get chain header2053 * @example getLatestBlockNumber();2054 * @returns the number of the last block2055 */2056 async getLatestBlockNumber(): Promise<number> {2057 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2058 }20592060 /**2061 * Get block hash by block number2062 * @param blockNumber number of block2063 * @example getBlockHashByNumber(12345);2064 * @returns hash of a block2065 */2066 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2067 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2068 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2069 return blockHash;2070 }20712072 // TODO add docs2073 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2074 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2075 if (!blockHash) return null;2076 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2077 }20782079 /**2080 * Get account nonce2081 * @param address substrate address2082 * @example getNonce("5GrwvaEF5zXb26Fz...");2083 * @returns number, account's nonce2084 */2085 async getNonce(address: TSubstrateAccount): Promise<number> {2086 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2087 }2088}20892090class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2091 /**2092 * Get substrate address balance2093 * @param address substrate address2094 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2095 * @returns amount of tokens on address2096 */2097 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2098 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2099 }21002101 /**2102 * Transfer tokens to substrate address2103 * @param signer keyring of signer2104 * @param address substrate address of a recipient2105 * @param amount amount of tokens to be transfered2106 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2107 * @returns ```true``` if extrinsic success, otherwise ```false```2108 */2109 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2110 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}`*/);21112112 let transfer = {from: null, to: null, amount: 0n} as any;2113 result.result.events.forEach(({event: {data, method, section}}) => {2114 if ((section === 'balances') && (method === 'Transfer')) {2115 transfer = {2116 from: this.helper.address.normalizeSubstrate(data[0]),2117 to: this.helper.address.normalizeSubstrate(data[1]),2118 amount: BigInt(data[2]),2119 };2120 }2121 });2122 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from 2123 && this.helper.address.normalizeSubstrate(address) === transfer.to 2124 && BigInt(amount) === transfer.amount;2125 return isSuccess;2126 }21272128 /**2129 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2130 * @param address substrate address2131 * @returns2132 */2133 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2134 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2135 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2136 }2137}21382139class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2140 /**2141 * Get ethereum address balance2142 * @param address ethereum address2143 * @example getEthereum("0x9F0583DbB855d...")2144 * @returns amount of tokens on address2145 */2146 async getEthereum(address: TEthereumAccount): Promise<bigint> {2147 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2148 }21492150 /**2151 * Transfer tokens to address2152 * @param signer keyring of signer2153 * @param address Ethereum address of a recipient2154 * @param amount amount of tokens to be transfered2155 * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2156 * @returns ```true``` if extrinsic success, otherwise ```false```2157 */2158 async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2159 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);21602161 let transfer = {from: null, to: null, amount: 0n} as any;2162 result.result.events.forEach(({event: {data, method, section}}) => {2163 if ((section === 'balances') && (method === 'Transfer')) {2164 transfer = {2165 from: data[0].toString(),2166 to: data[1].toString(),2167 amount: BigInt(data[2]),2168 };2169 }2170 });2171 const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from 2172 && address === transfer.to 2173 && BigInt(amount) === transfer.amount;2174 return isSuccess;2175 }2176}21772178class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2179 subBalanceGroup: SubstrateBalanceGroup<T>;2180 ethBalanceGroup: EthereumBalanceGroup<T>;21812182 constructor(helper: T) {2183 super(helper);2184 this.subBalanceGroup = new SubstrateBalanceGroup(helper);2185 this.ethBalanceGroup = new EthereumBalanceGroup(helper);2186 }21872188 getCollectionCreationPrice(): bigint {2189 return 2n * this.getOneTokenNominal();2190 }2191 /**2192 * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2193 * @example getOneTokenNominal()2194 * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2195 */2196 getOneTokenNominal(): bigint {2197 const chainProperties = this.helper.chain.getChainProperties();2198 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2199 }22002201 /**2202 * Get substrate address balance2203 * @param address substrate address2204 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2205 * @returns amount of tokens on address2206 */2207 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2208 return this.subBalanceGroup.getSubstrate(address);2209 }22102211 /**2212 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2213 * @param address substrate address2214 * @returns2215 */2216 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2217 return this.subBalanceGroup.getSubstrateFull(address);2218 }22192220 /**2221 * Get ethereum address balance2222 * @param address ethereum address2223 * @example getEthereum("0x9F0583DbB855d...")2224 * @returns amount of tokens on address2225 */2226 async getEthereum(address: TEthereumAccount): Promise<bigint> {2227 return this.ethBalanceGroup.getEthereum(address);2228 }22292230 /**2231 * Transfer tokens to substrate address2232 * @param signer keyring of signer2233 * @param address substrate address of a recipient2234 * @param amount amount of tokens to be transfered2235 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2236 * @returns ```true``` if extrinsic success, otherwise ```false```2237 */2238 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2239 return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2240 }2241}22422243class AddressGroup extends HelperGroup<ChainHelperBase> {2244 /**2245 * Normalizes the address to the specified ss58 format, by default ```42```.2246 * @param address substrate address2247 * @param ss58Format format for address conversion, by default ```42```2248 * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2249 * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2250 */2251 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2252 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2253 }22542255 /**2256 * Get address in the connected chain format2257 * @param address substrate address2258 * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2259 * @returns address in chain format2260 */2261 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2262 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2263 }22642265 /**2266 * Get substrate mirror of an ethereum address2267 * @param ethAddress ethereum address2268 * @param toChainFormat false for normalized account2269 * @example ethToSubstrate('0x9F0583DbB855d...')2270 * @returns substrate mirror of a provided ethereum address2271 */2272 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2273 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2274 }22752276 /**2277 * Get ethereum mirror of a substrate address2278 * @param subAddress substrate account2279 * @example substrateToEth("5DnSF6RRjwteE3BrC...")2280 * @returns ethereum mirror of a provided substrate address2281 */2282 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2283 return CrossAccountId.translateSubToEth(subAddress);2284 }2285}22862287class StakingGroup extends HelperGroup<UniqueHelper> {2288 /**2289 * Stake tokens for App Promotion2290 * @param signer keyring of signer2291 * @param amountToStake amount of tokens to stake2292 * @param label extra label for log2293 * @returns2294 */2295 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2296 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2297 const _stakeResult = await this.helper.executeExtrinsic(2298 signer, 'api.tx.appPromotion.stake',2299 [amountToStake], true,2300 );2301 // TODO extract info from stakeResult2302 return true;2303 }23042305 /**2306 * Unstake tokens for App Promotion2307 * @param signer keyring of signer2308 * @param amountToUnstake amount of tokens to unstake2309 * @param label extra label for log2310 * @returns block number where balances will be unlocked2311 */2312 async unstake(signer: TSigner, label?: string): Promise<number> {2313 if(typeof label === 'undefined') label = `${signer.address}`;2314 const _unstakeResult = await this.helper.executeExtrinsic(2315 signer, 'api.tx.appPromotion.unstake',2316 [], true,2317 );2318 // TODO extract block number fron events2319 return 1;2320 }23212322 /**2323 * Get total staked amount for address2324 * @param address substrate or ethereum address2325 * @returns total staked amount2326 */2327 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2328 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2329 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2330 }23312332 /**2333 * Get total staked per block2334 * @param address substrate or ethereum address2335 * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2336 */2337 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2338 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2339 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2340 return { 2341 block: block.toBigInt(),2342 amount: amount.toBigInt(),2343 };2344 });2345 }23462347 /**2348 * Get total pending unstake amount for address2349 * @param address substrate or ethereum address2350 * @returns total pending unstake amount2351 */2352 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2353 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2354 }23552356 /**2357 * Get pending unstake amount per block for address2358 * @param address substrate or ethereum address2359 * @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 block2360 */2361 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2362 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2363 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2364 return {2365 block: block.toBigInt(),2366 amount: amount.toBigInt(),2367 };2368 });2369 return result;2370 }2371}23722373class SchedulerGroup extends HelperGroup<UniqueHelper> {2374 constructor(helper: UniqueHelper) {2375 super(helper);2376 }23772378 async cancelScheduled(signer: TSigner, scheduledId: string) {2379 return this.helper.executeExtrinsic(2380 signer,2381 'api.tx.scheduler.cancelNamed',2382 [scheduledId],2383 true,2384 );2385 }23862387 async changePriority(signer: TSigner, scheduledId: string, priority: number) {2388 return this.helper.executeExtrinsic(2389 signer,2390 'api.tx.scheduler.changeNamedPriority',2391 [scheduledId, priority],2392 true,2393 );2394 }23952396 scheduleAt<T extends UniqueHelper>(2397 scheduledId: string,2398 executionBlockNumber: number,2399 options: ISchedulerOptions = {},2400 ) {2401 return this.schedule<T>('scheduleNamed', scheduledId, executionBlockNumber, options);2402 }24032404 scheduleAfter<T extends UniqueHelper>(2405 scheduledId: string,2406 blocksBeforeExecution: number,2407 options: ISchedulerOptions = {},2408 ) {2409 return this.schedule<T>('scheduleNamedAfter', scheduledId, blocksBeforeExecution, options);2410 }24112412 schedule<T extends UniqueHelper>(2413 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter',2414 scheduledId: string,2415 blocksNum: number,2416 options: ISchedulerOptions = {},2417 ) {2418 // eslint-disable-next-line @typescript-eslint/naming-convention2419 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2420 return this.helper.clone(ScheduledHelperType, {2421 scheduleFn,2422 scheduledId,2423 blocksNum,2424 options,2425 }) as T;2426 }2427}24282429class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2430 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2431 await this.helper.executeExtrinsic(2432 signer,2433 'api.tx.foreignAssets.registerForeignAsset',2434 [ownerAddress, location, metadata],2435 true,2436 );2437 }24382439 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2440 await this.helper.executeExtrinsic(2441 signer,2442 'api.tx.foreignAssets.updateForeignAsset',2443 [foreignAssetId, location, metadata],2444 true,2445 );2446 }2447}24482449class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2450 palletName: string;24512452 constructor(helper: T, palletName: string) {2453 super(helper);24542455 this.palletName = palletName;2456 }24572458 async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: number) {2459 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, {Limited: weightLimit}], true);2460 }2461}24622463class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2464 async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: number) {2465 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);2466 }24672468 async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: number) {2469 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);2470 }2471}24722473class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2474 async accounts(address: string, currencyId: any) {2475 const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;2476 return BigInt(free);2477 }2478}24792480class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {2481 async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {2482 await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);2483 }2484}24852486class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {2487 makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {2488 const apiPrefix = 'api.tx.assetManager.';24892490 const registerTx = this.helper.constructApiCall(2491 apiPrefix + 'registerForeignAsset',2492 [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],2493 );24942495 const setUnitsTx = this.helper.constructApiCall(2496 apiPrefix + 'setAssetUnitsPerSecond',2497 [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],2498 );24992500 const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);2501 const encodedProposal = batchCall?.method.toHex() || '';2502 return encodedProposal;2503 }25042505 async assetTypeId(location: any) {2506 return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);2507 }2508}25092510class MoonbeamAssetsGroup extends HelperGroup<MoonbeamHelper> {2511 async account(assetId: string, address: string) {2512 const accountAsset = (2513 await this.helper.callRpc('api.query.assets.account', [assetId, address])2514 ).toJSON()! as any;25152516 if (accountAsset !== null) {2517 return BigInt(accountAsset['balance']);2518 } else {2519 return null;2520 }2521 }2522}25232524class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {2525 async notePreimage(signer: TSigner, encodedProposal: string) {2526 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.notePreimage', [encodedProposal], true);2527 }25282529 externalProposeMajority(proposalHash: string) {2530 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposalHash]);2531 }25322533 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {2534 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);2535 }25362537 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {2538 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);2539 }2540}25412542class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {2543 collective: string;25442545 constructor(helper: MoonbeamHelper, collective: string) {2546 super(helper);25472548 this.collective = collective;2549 }25502551 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {2552 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);2553 }25542555 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {2556 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);2557 }25582559 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: number, lengthBound: number) {2560 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);2561 }25622563 async proposalCount() {2564 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));2565 }2566}25672568export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;2569export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;25702571export class UniqueHelper extends ChainHelperBase {2572 balance: BalanceGroup<UniqueHelper>;2573 collection: CollectionGroup;2574 nft: NFTGroup;2575 rft: RFTGroup;2576 ft: FTGroup;2577 staking: StakingGroup;2578 scheduler: SchedulerGroup;2579 foreignAssets: ForeignAssetsGroup;2580 xcm: XcmGroup<UniqueHelper>;2581 xTokens: XTokensGroup<UniqueHelper>;2582 tokens: TokensGroup<UniqueHelper>;25832584 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2585 super(logger, options.helperBase ?? UniqueHelper);25862587 this.balance = new BalanceGroup(this);2588 this.address = new AddressGroup(this);2589 this.collection = new CollectionGroup(this);2590 this.nft = new NFTGroup(this);2591 this.rft = new RFTGroup(this);2592 this.ft = new FTGroup(this);2593 this.staking = new StakingGroup(this);2594 this.scheduler = new SchedulerGroup(this);2595 this.foreignAssets = new ForeignAssetsGroup(this);2596 this.xcm = new XcmGroup(this, 'polkadotXcm');2597 this.xTokens = new XTokensGroup(this);2598 this.tokens = new TokensGroup(this);2599 }26002601 getSudo<T extends UniqueHelper>() {2602 // eslint-disable-next-line @typescript-eslint/naming-convention2603 const SudoHelperType = SudoHelper(this.helperBase);2604 return this.clone(SudoHelperType) as T;2605 }2606}26072608export class XcmChainHelper extends ChainHelperBase {2609 async connect(wsEndpoint: string, _listeners?: any): Promise<void> {2610 const wsProvider = new WsProvider(wsEndpoint);2611 this.api = new ApiPromise({2612 provider: wsProvider,2613 });2614 await this.api.isReadyOrError;2615 this.network = await UniqueHelper.detectNetwork(this.api);2616 }2617}26182619export class RelayHelper extends XcmChainHelper {2620 xcm: XcmGroup<RelayHelper>;26212622 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2623 super(logger, options.helperBase ?? RelayHelper);26242625 this.xcm = new XcmGroup(this, 'xcmPallet');2626 }2627}26282629export class MoonbeamHelper extends XcmChainHelper {2630 balance: EthereumBalanceGroup<MoonbeamHelper>;2631 assetManager: MoonbeamAssetManagerGroup;2632 assets: MoonbeamAssetsGroup;2633 xTokens: XTokensGroup<MoonbeamHelper>;2634 democracy: MoonbeamDemocracyGroup;2635 collective: {2636 council: MoonbeamCollectiveGroup,2637 techCommittee: MoonbeamCollectiveGroup,2638 };26392640 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2641 super(logger, options.helperBase ?? MoonbeamHelper);26422643 this.balance = new EthereumBalanceGroup(this);2644 this.assetManager = new MoonbeamAssetManagerGroup(this);2645 this.assets = new MoonbeamAssetsGroup(this);2646 this.xTokens = new XTokensGroup(this);2647 this.democracy = new MoonbeamDemocracyGroup(this);2648 this.collective = {2649 council: new MoonbeamCollectiveGroup(this, 'councilCollective'),2650 techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),2651 };2652 }2653}26542655export class AcalaHelper extends XcmChainHelper {2656 balance: SubstrateBalanceGroup<AcalaHelper>;2657 assetRegistry: AcalaAssetRegistryGroup;2658 xTokens: XTokensGroup<AcalaHelper>;2659 tokens: TokensGroup<AcalaHelper>;26602661 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2662 super(logger, options.helperBase ?? AcalaHelper);26632664 this.balance = new SubstrateBalanceGroup(this);2665 this.assetRegistry = new AcalaAssetRegistryGroup(this);2666 this.xTokens = new XTokensGroup(this);2667 this.tokens = new TokensGroup(this);2668 }26692670 getSudo<T extends AcalaHelper>() {2671 // eslint-disable-next-line @typescript-eslint/naming-convention2672 const SudoHelperType = SudoHelper(this.helperBase);2673 return this.clone(SudoHelperType) as T;2674 }2675}26762677// eslint-disable-next-line @typescript-eslint/naming-convention2678function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {2679 return class extends Base {2680 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter';2681 scheduledId: string;2682 blocksNum: number;2683 options: ISchedulerOptions;26842685 constructor(...args: any[]) {2686 const logger = args[0] as ILogger;2687 const options = args[1] as {2688 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter',2689 scheduledId: string,2690 blocksNum: number,2691 options: ISchedulerOptions2692 };26932694 super(logger);26952696 this.scheduleFn = options.scheduleFn;2697 this.scheduledId = options.scheduledId;2698 this.blocksNum = options.blocksNum;2699 this.options = options.options;2700 }27012702 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {2703 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);2704 const extrinsic = 'api.tx.scheduler.' + this.scheduleFn;27052706 return super.executeExtrinsic(2707 sender,2708 extrinsic,2709 [2710 this.scheduledId,2711 this.blocksNum,2712 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,2713 this.options.priority ?? null,2714 {Value: scheduledTx},2715 ],2716 expectSuccess,2717 );2718 }2719 };2720}27212722// eslint-disable-next-line @typescript-eslint/naming-convention2723function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {2724 return class extends Base {2725 constructor(...args: any[]) {2726 super(...args);2727 }27282729 executeExtrinsic (2730 sender: IKeyringPair,2731 extrinsic: string,2732 params: any[],2733 expectSuccess?: boolean,2734 ): Promise<ITransactionResult> {2735 const call = this.constructApiCall(extrinsic, params);27362737 return super.executeExtrinsic(2738 sender,2739 'api.tx.sudo.sudo',2740 [call],2741 expectSuccess,2742 );2743 }2744 };2745}27462747export class UniqueBaseCollection {2748 helper: UniqueHelper;2749 collectionId: number;27502751 constructor(collectionId: number, uniqueHelper: UniqueHelper) {2752 this.collectionId = collectionId;2753 this.helper = uniqueHelper;2754 }27552756 async getData() {2757 return await this.helper.collection.getData(this.collectionId);2758 }27592760 async getLastTokenId() {2761 return await this.helper.collection.getLastTokenId(this.collectionId);2762 }27632764 async doesTokenExist(tokenId: number) {2765 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);2766 }27672768 async getAdmins() {2769 return await this.helper.collection.getAdmins(this.collectionId);2770 }27712772 async getAllowList() {2773 return await this.helper.collection.getAllowList(this.collectionId);2774 }27752776 async getEffectiveLimits() {2777 return await this.helper.collection.getEffectiveLimits(this.collectionId);2778 }27792780 async getProperties(propertyKeys?: string[] | null) {2781 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);2782 }27832784 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {2785 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);2786 }27872788 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {2789 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);2790 }27912792 async confirmSponsorship(signer: TSigner) {2793 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);2794 }27952796 async removeSponsor(signer: TSigner) {2797 return await this.helper.collection.removeSponsor(signer, this.collectionId);2798 }27992800 async setLimits(signer: TSigner, limits: ICollectionLimits) {2801 return await this.helper.collection.setLimits(signer, this.collectionId, limits);2802 }28032804 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {2805 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);2806 }28072808 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2809 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);2810 }28112812 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {2813 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);2814 }28152816 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {2817 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);2818 }28192820 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2821 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);2822 }28232824 async setProperties(signer: TSigner, properties: IProperty[]) {2825 return await this.helper.collection.setProperties(signer, this.collectionId, properties);2826 }28272828 async deleteProperties(signer: TSigner, propertyKeys: string[]) {2829 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);2830 }28312832 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {2833 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);2834 }28352836 async enableNesting(signer: TSigner, permissions: INestingPermissions) {2837 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);2838 }28392840 async disableNesting(signer: TSigner) {2841 return await this.helper.collection.disableNesting(signer, this.collectionId);2842 }28432844 async burn(signer: TSigner) {2845 return await this.helper.collection.burn(signer, this.collectionId);2846 }28472848 scheduleAt<T extends UniqueHelper>(2849 scheduledId: string,2850 executionBlockNumber: number,2851 options: ISchedulerOptions = {},2852 ) {2853 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);2854 return new UniqueBaseCollection(this.collectionId, scheduledHelper);2855 }28562857 scheduleAfter<T extends UniqueHelper>(2858 scheduledId: string,2859 blocksBeforeExecution: number,2860 options: ISchedulerOptions = {},2861 ) {2862 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);2863 return new UniqueBaseCollection(this.collectionId, scheduledHelper);2864 }28652866 getSudo<T extends UniqueHelper>() {2867 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());2868 }2869}287028712872export class UniqueNFTCollection extends UniqueBaseCollection {2873 getTokenObject(tokenId: number) {2874 return new UniqueNFToken(tokenId, this);2875 }28762877 async getTokensByAddress(addressObj: ICrossAccountId) {2878 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);2879 }28802881 async getToken(tokenId: number, blockHashAt?: string) {2882 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);2883 }28842885 async getTokenOwner(tokenId: number, blockHashAt?: string) {2886 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);2887 }28882889 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {2890 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);2891 }28922893 async getTokenChildren(tokenId: number, blockHashAt?: string) {2894 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);2895 }28962897 async getPropertyPermissions(propertyKeys: string[] | null = null) {2898 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);2899 }29002901 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {2902 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);2903 }29042905 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {2906 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);2907 }29082909 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2910 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);2911 }29122913 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {2914 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);2915 }29162917 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {2918 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);2919 }29202921 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {2922 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});2923 }29242925 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {2926 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);2927 }29282929 async burnToken(signer: TSigner, tokenId: number) {2930 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);2931 }29322933 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {2934 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);2935 }29362937 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {2938 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);2939 }29402941 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {2942 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);2943 }29442945 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {2946 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);2947 }29482949 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {2950 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);2951 }29522953 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {2954 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);2955 }29562957 scheduleAt<T extends UniqueHelper>(2958 scheduledId: string,2959 executionBlockNumber: number,2960 options: ISchedulerOptions = {},2961 ) {2962 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);2963 return new UniqueNFTCollection(this.collectionId, scheduledHelper);2964 }29652966 scheduleAfter<T extends UniqueHelper>(2967 scheduledId: string,2968 blocksBeforeExecution: number,2969 options: ISchedulerOptions = {},2970 ) {2971 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);2972 return new UniqueNFTCollection(this.collectionId, scheduledHelper);2973 }29742975 getSudo<T extends UniqueHelper>() {2976 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());2977 }2978}297929802981export class UniqueRFTCollection extends UniqueBaseCollection {2982 getTokenObject(tokenId: number) {2983 return new UniqueRFToken(tokenId, this);2984 }29852986 async getToken(tokenId: number, blockHashAt?: string) {2987 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);2988 }29892990 async getTokensByAddress(addressObj: ICrossAccountId) {2991 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);2992 }29932994 async getTop10TokenOwners(tokenId: number) {2995 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);2996 }29972998 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {2999 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3000 }30013002 async getTokenTotalPieces(tokenId: number) {3003 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3004 }30053006 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3007 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3008 }30093010 async getPropertyPermissions(propertyKeys: string[] | null = null) {3011 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3012 }30133014 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3015 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3016 }30173018 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3019 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3020 }30213022 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3023 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3024 }30253026 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3027 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3028 }30293030 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3031 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3032 }30333034 async mintToken(signer: TSigner, pieces=1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3035 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3036 }30373038 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3039 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3040 }30413042 async burnToken(signer: TSigner, tokenId: number, amount=1n) {3043 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3044 }30453046 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {3047 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3048 }30493050 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3051 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3052 }30533054 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3055 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3056 }30573058 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3059 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3060 }30613062 scheduleAt<T extends UniqueHelper>(3063 scheduledId: string,3064 executionBlockNumber: number,3065 options: ISchedulerOptions = {},3066 ) {3067 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);3068 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3069 }30703071 scheduleAfter<T extends UniqueHelper>(3072 scheduledId: string,3073 blocksBeforeExecution: number,3074 options: ISchedulerOptions = {},3075 ) {3076 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3077 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3078 }30793080 getSudo<T extends UniqueHelper>() {3081 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3082 }3083}308430853086export class UniqueFTCollection extends UniqueBaseCollection {3087 async getBalance(addressObj: ICrossAccountId) {3088 return await this.helper.ft.getBalance(this.collectionId, addressObj);3089 }30903091 async getTotalPieces() {3092 return await this.helper.ft.getTotalPieces(this.collectionId);3093 }30943095 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3096 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3097 }30983099 async getTop10Owners() {3100 return await this.helper.ft.getTop10Owners(this.collectionId);3101 }31023103 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3104 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3105 }31063107 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3108 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3109 }31103111 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3112 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3113 }31143115 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3116 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3117 }31183119 async burnTokens(signer: TSigner, amount=1n) {3120 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3121 }31223123 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3124 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3125 }31263127 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3128 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3129 }31303131 scheduleAt<T extends UniqueHelper>(3132 scheduledId: string,3133 executionBlockNumber: number,3134 options: ISchedulerOptions = {},3135 ) {3136 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);3137 return new UniqueFTCollection(this.collectionId, scheduledHelper);3138 }31393140 scheduleAfter<T extends UniqueHelper>(3141 scheduledId: string,3142 blocksBeforeExecution: number,3143 options: ISchedulerOptions = {},3144 ) {3145 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3146 return new UniqueFTCollection(this.collectionId, scheduledHelper);3147 }31483149 getSudo<T extends UniqueHelper>() {3150 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3151 }3152}315331543155export class UniqueBaseToken {3156 collection: UniqueNFTCollection | UniqueRFTCollection;3157 collectionId: number;3158 tokenId: number;31593160 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3161 this.collection = collection;3162 this.collectionId = collection.collectionId;3163 this.tokenId = tokenId;3164 }31653166 async getNextSponsored(addressObj: ICrossAccountId) {3167 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3168 }31693170 async getProperties(propertyKeys?: string[] | null) {3171 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3172 }31733174 async setProperties(signer: TSigner, properties: IProperty[]) {3175 return await this.collection.setTokenProperties(signer, this.tokenId, properties);3176 }31773178 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3179 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3180 }31813182 async doesExist() {3183 return await this.collection.doesTokenExist(this.tokenId);3184 }31853186 nestingAccount() {3187 return this.collection.helper.util.getTokenAccount(this);3188 }31893190 scheduleAt<T extends UniqueHelper>(3191 scheduledId: string,3192 executionBlockNumber: number,3193 options: ISchedulerOptions = {},3194 ) {3195 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);3196 return new UniqueBaseToken(this.tokenId, scheduledCollection);3197 }31983199 scheduleAfter<T extends UniqueHelper>(3200 scheduledId: string,3201 blocksBeforeExecution: number,3202 options: ISchedulerOptions = {},3203 ) {3204 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3205 return new UniqueBaseToken(this.tokenId, scheduledCollection);3206 }32073208 getSudo<T extends UniqueHelper>() {3209 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3210 }3211}321232133214export class UniqueNFToken extends UniqueBaseToken {3215 collection: UniqueNFTCollection;32163217 constructor(tokenId: number, collection: UniqueNFTCollection) {3218 super(tokenId, collection);3219 this.collection = collection;3220 }32213222 async getData(blockHashAt?: string) {3223 return await this.collection.getToken(this.tokenId, blockHashAt);3224 }32253226 async getOwner(blockHashAt?: string) {3227 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3228 }32293230 async getTopmostOwner(blockHashAt?: string) {3231 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3232 }32333234 async getChildren(blockHashAt?: string) {3235 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3236 }32373238 async nest(signer: TSigner, toTokenObj: IToken) {3239 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3240 }32413242 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3243 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3244 }32453246 async transfer(signer: TSigner, addressObj: ICrossAccountId) {3247 return await this.collection.transferToken(signer, this.tokenId, addressObj);3248 }32493250 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3251 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3252 }32533254 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3255 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3256 }32573258 async isApproved(toAddressObj: ICrossAccountId) {3259 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3260 }32613262 async burn(signer: TSigner) {3263 return await this.collection.burnToken(signer, this.tokenId);3264 }32653266 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3267 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3268 }32693270 scheduleAt<T extends UniqueHelper>(3271 scheduledId: string,3272 executionBlockNumber: number,3273 options: ISchedulerOptions = {},3274 ) {3275 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);3276 return new UniqueNFToken(this.tokenId, scheduledCollection);3277 }32783279 scheduleAfter<T extends UniqueHelper>(3280 scheduledId: string,3281 blocksBeforeExecution: number,3282 options: ISchedulerOptions = {},3283 ) {3284 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3285 return new UniqueNFToken(this.tokenId, scheduledCollection);3286 }32873288 getSudo<T extends UniqueHelper>() {3289 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3290 }3291}32923293export class UniqueRFToken extends UniqueBaseToken {3294 collection: UniqueRFTCollection;32953296 constructor(tokenId: number, collection: UniqueRFTCollection) {3297 super(tokenId, collection);3298 this.collection = collection;3299 }33003301 async getData(blockHashAt?: string) {3302 return await this.collection.getToken(this.tokenId, blockHashAt);3303 }33043305 async getTop10Owners() {3306 return await this.collection.getTop10TokenOwners(this.tokenId);3307 }33083309 async getBalance(addressObj: ICrossAccountId) {3310 return await this.collection.getTokenBalance(this.tokenId, addressObj);3311 }33123313 async getTotalPieces() {3314 return await this.collection.getTokenTotalPieces(this.tokenId);3315 }33163317 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {3318 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);3319 }33203321 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {3322 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);3323 }33243325 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3326 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);3327 }33283329 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3330 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);3331 }33323333 async repartition(signer: TSigner, amount: bigint) {3334 return await this.collection.repartitionToken(signer, this.tokenId, amount);3335 }33363337 async burn(signer: TSigner, amount=1n) {3338 return await this.collection.burnToken(signer, this.tokenId, amount);3339 }33403341 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3342 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);3343 }33443345 scheduleAt<T extends UniqueHelper>(3346 scheduledId: string,3347 executionBlockNumber: number,3348 options: ISchedulerOptions = {},3349 ) {3350 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);3351 return new UniqueRFToken(this.tokenId, scheduledCollection);3352 }33533354 scheduleAfter<T extends UniqueHelper>(3355 scheduledId: string,3356 blocksBeforeExecution: number,3357 options: ISchedulerOptions = {},3358 ) {3359 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3360 return new UniqueRFToken(this.tokenId, scheduledCollection);3361 }33623363 getSudo<T extends UniqueHelper>() {3364 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());3365 }3366}