12345678import {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';13import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';1415export class CrossAccountId implements ICrossAccountId {16 Substrate?: TSubstrateAccount;17 Ethereum?: TEthereumAccount;1819 constructor(account: ICrossAccountId) {20 if (account.Substrate) this.Substrate = account.Substrate;21 if (account.Ethereum) this.Ethereum = account.Ethereum;22 }2324 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {25 switch (domain) {26 case 'Substrate': return new CrossAccountId({Substrate: account.address});27 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();28 }29 }3031 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {32 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});33 }3435 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {36 return encodeAddress(decodeAddress(address), ss58Format);37 }3839 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {40 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});41 }42 43 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {44 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);45 return this;46 }4748 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {49 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));50 }5152 toEthereum(): CrossAccountId {53 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});54 return this;55 }5657 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {58 return evmToAddress(address, ss58Format);59 }6061 toSubstrate(ss58Format?: number): CrossAccountId {62 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});63 return this;64 }65 66 toLowerCase(): CrossAccountId {67 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();68 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();69 return this;70 }71}7273const nesting = {74 toChecksumAddress(address: string): string {75 if (typeof address === 'undefined') return '';7677 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);7879 address = address.toLowerCase().replace(/^0x/i,'');80 const addressHash = keccakAsHex(address).replace(/^0x/i,'');81 const checksumAddress = ['0x'];8283 for (let i = 0; i < address.length; i++) {84 85 if (parseInt(addressHash[i], 16) > 7) {86 checksumAddress.push(address[i].toUpperCase());87 } else {88 checksumAddress.push(address[i]);89 }90 }91 return checksumAddress.join('');92 },93 tokenIdToAddress(collectionId: number, tokenId: number) {94 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8, '0')}${tokenId.toString(16).padStart(8, '0')}`);95 },96};9798class UniqueUtil {99 static transactionStatus = {100 NOT_READY: 'NotReady',101 FAIL: 'Fail',102 SUCCESS: 'Success',103 };104105 static chainLogType = {106 EXTRINSIC: 'extrinsic',107 RPC: 'rpc',108 };109110 static getTokenAccount(token: IToken): CrossAccountId {111 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});112 }113114 static getTokenAddress(token: IToken): string {115 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);116 }117118 static getDefaultLogger(): ILogger {119 return {120 log(msg: any, level = 'INFO') {121 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));122 },123 level: {124 ERROR: 'ERROR',125 WARNING: 'WARNING',126 INFO: 'INFO',127 },128 };129 }130131 static vec2str(arr: string[] | number[]) {132 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');133 }134135 static str2vec(string: string) {136 if (typeof string !== 'string') return string;137 return Array.from(string).map(x => x.charCodeAt(0));138 }139140 static fromSeed(seed: string, ss58Format = 42) {141 const keyring = new Keyring({type: 'sr25519', ss58Format});142 return keyring.addFromUri(seed);143 }144145 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {146 if (creationResult.status !== this.transactionStatus.SUCCESS) {147 throw Error('Unable to create collection!');148 }149150 let collectionId = null;151 creationResult.result.events.forEach(({event: {data, method, section}}) => {152 if ((section === 'common') && (method === 'CollectionCreated')) {153 collectionId = parseInt(data[0].toString(), 10);154 }155 });156157 if (collectionId === null) {158 throw Error('No CollectionCreated event was found!');159 }160161 return collectionId;162 }163164 static extractTokensFromCreationResult(creationResult: ITransactionResult): {165 success: boolean, 166 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],167 } {168 if (creationResult.status !== this.transactionStatus.SUCCESS) {169 throw Error('Unable to create tokens!');170 }171 let success = false;172 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];173 creationResult.result.events.forEach(({event: {data, method, section}}) => {174 if (method === 'ExtrinsicSuccess') {175 success = true;176 } else if ((section === 'common') && (method === 'ItemCreated')) {177 tokens.push({178 collectionId: parseInt(data[0].toString(), 10),179 tokenId: parseInt(data[1].toString(), 10),180 owner: data[2].toHuman(),181 amount: data[3].toBigInt(),182 });183 }184 });185 return {success, tokens};186 }187188 static extractTokensFromBurnResult(burnResult: ITransactionResult): {189 success: boolean, 190 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],191 } {192 if (burnResult.status !== this.transactionStatus.SUCCESS) {193 throw Error('Unable to burn tokens!');194 }195 let success = false;196 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];197 burnResult.result.events.forEach(({event: {data, method, section}}) => {198 if (method === 'ExtrinsicSuccess') {199 success = true;200 } else if ((section === 'common') && (method === 'ItemDestroyed')) {201 tokens.push({202 collectionId: parseInt(data[0].toString(), 10),203 tokenId: parseInt(data[1].toString(), 10),204 owner: data[2].toHuman(),205 amount: data[3].toBigInt(),206 });207 }208 });209 return {success, tokens};210 }211212 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {213 let eventId = null;214 events.forEach(({event: {data, method, section}}) => {215 if ((section === expectedSection) && (method === expectedMethod)) {216 eventId = parseInt(data[0].toString(), 10);217 }218 });219220 if (eventId === null) {221 throw Error(`No ${expectedMethod} event was found!`);222 }223 return eventId === collectionId;224 }225226 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {227 const normalizeAddress = (address: string | ICrossAccountId) => {228 if(typeof address === 'string') return address;229 const obj = {} as any;230 Object.keys(address).forEach(k => {231 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];232 });233 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);234 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();235 return address;236 };237 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;238 events.forEach(({event: {data, method, section}}) => {239 if ((section === 'common') && (method === 'Transfer')) {240 const hData = (data as any).toJSON();241 transfer = {242 collectionId: hData[0],243 tokenId: hData[1],244 from: normalizeAddress(hData[2]),245 to: normalizeAddress(hData[3]),246 amount: BigInt(hData[4]),247 };248 }249 });250 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;251 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);252 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);253 isSuccess = isSuccess && amount === transfer.amount;254 return isSuccess;255 }256257 static bigIntToDecimals(number: bigint, decimals = 18) {258 const numberStr = number.toString();259 const dotPos = numberStr.length - decimals;260 261 if (dotPos <= 0) {262 return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;263 } else {264 const intPart = numberStr.substring(0, dotPos);265 const fractPart = numberStr.substring(dotPos);266 return intPart + '.' + fractPart;267 }268 }269}270271class UniqueEventHelper {272 private static extractIndex(index: any): [number, number] | string {273 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];274 return index.toJSON();275 }276277 private static extractSub(data: any, subTypes: any): {[key: string]: any} {278 let obj: any = {};279 let index = 0;280281 if (data.entries) {282 for(const [key, value] of data.entries()) {283 obj[key] = this.extractData(value, subTypes[index]);284 index++;285 }286 } else obj = data.toJSON();287288 return obj;289 }290 291 private static extractData(data: any, type: any): any {292 if(!type) return data.toHuman();293 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();294 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();295 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);296 return data.toHuman();297 }298299 public static extractEvents(events: {event: any, phase: any}[]): IEvent[] {300 const parsedEvents: IEvent[] = [];301302 events.forEach((record) => {303 const {event, phase} = record;304 const types = event.typeDef;305306 const eventData: IEvent = {307 section: event.section.toString(),308 method: event.method.toString(),309 index: this.extractIndex(event.index),310 data: [],311 phase: phase.toJSON(),312 };313314 event.data.forEach((val: any, index: number) => {315 eventData.data.push(this.extractData(val, types[index]));316 });317318 parsedEvents.push(eventData);319 });320321 return parsedEvents;322 }323}324325export class ChainHelperBase {326 helperBase: any;327328 transactionStatus = UniqueUtil.transactionStatus;329 chainLogType = UniqueUtil.chainLogType;330 util: typeof UniqueUtil;331 eventHelper: typeof UniqueEventHelper;332 logger: ILogger;333 api: ApiPromise | null;334 forcedNetwork: TNetworks | null;335 network: TNetworks | null;336 chainLog: IUniqueHelperLog[];337 children: ChainHelperBase[];338 address: AddressGroup;339 chain: ChainGroup;340341 constructor(logger?: ILogger, helperBase?: any) {342 this.helperBase = helperBase;343344 this.util = UniqueUtil;345 this.eventHelper = UniqueEventHelper;346 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();347 this.logger = logger;348 this.api = null;349 this.forcedNetwork = null;350 this.network = null;351 this.chainLog = [];352 this.children = [];353 this.address = new AddressGroup(this);354 this.chain = new ChainGroup(this);355 }356357 clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {358 Object.setPrototypeOf(helperCls.prototype, this);359 const newHelper = new helperCls(this.logger, options);360361 newHelper.api = this.api;362 newHelper.network = this.network;363 newHelper.forceNetwork = this.forceNetwork;364365 this.children.push(newHelper);366367 return newHelper;368 }369370 getApi(): ApiPromise {371 if(this.api === null) throw Error('API not initialized');372 return this.api;373 }374375 clearChainLog(): void {376 this.chainLog = [];377 }378379 forceNetwork(value: TNetworks): void {380 this.forcedNetwork = value;381 }382383 async connect(wsEndpoint: string, listeners?: IApiListeners) {384 if (this.api !== null) throw Error('Already connected');385 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);386 this.api = api;387 this.network = network;388 }389390 async disconnect() {391 for (const child of this.children) {392 child.clearApi();393 }394395 if (this.api === null) return;396 await this.api.disconnect();397 this.clearApi();398 }399400 clearApi() {401 this.api = null;402 this.network = null;403 }404405 static async detectNetwork(api: ApiPromise): Promise<TNetworks> {406 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;407 const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];408409 if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;410411 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;412 return 'opal';413 }414415 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {416 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});417 await api.isReady;418419 const network = await this.detectNetwork(api);420421 await api.disconnect();422423 return network;424 }425426 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{427 api: ApiPromise;428 network: TNetworks;429 }> {430 if(typeof network === 'undefined' || network === null) network = 'opal';431 const supportedRPC = {432 opal: {433 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,434 },435 quartz: {436 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,437 },438 unique: {439 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,440 },441 rococo: {},442 westend: {},443 moonbeam: {},444 moonriver: {},445 acala: {},446 karura: {},447 westmint: {},448 };449 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);450 const rpc = supportedRPC[network];451452 453 454455 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});456457 await api.isReadyOrError;458459 if (typeof listeners === 'undefined') listeners = {};460 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {461 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;462 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);463 }464465 return {api, network};466 }467468 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {469 const {events, status} = data;470 if (status.isReady) {471 return this.transactionStatus.NOT_READY;472 }473 if (status.isBroadcast) {474 return this.transactionStatus.NOT_READY;475 }476 if (status.isInBlock || status.isFinalized) {477 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');478 if (errors.length > 0) {479 return this.transactionStatus.FAIL;480 }481 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {482 return this.transactionStatus.SUCCESS;483 }484 }485486 return this.transactionStatus.FAIL;487 }488489 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {490 const sign = (callback: any) => {491 if(options !== null) return transaction.signAndSend(sender, options, callback);492 return transaction.signAndSend(sender, callback);493 };494 495 return new Promise(async (resolve, reject) => {496 try {497 const unsub = await sign((result: any) => {498 const status = this.getTransactionStatus(result);499500 if (status === this.transactionStatus.SUCCESS) {501 this.logger.log(`${label} successful`);502 unsub();503 resolve({result, status});504 } else if (status === this.transactionStatus.FAIL) {505 let moduleError = null;506507 if (result.hasOwnProperty('dispatchError')) {508 const dispatchError = result['dispatchError'];509510 if (dispatchError) {511 if (dispatchError.isModule) {512 const modErr = dispatchError.asModule;513 const errorMeta = dispatchError.registry.findMetaError(modErr);514515 moduleError = `${errorMeta.section}.${errorMeta.name}`;516 } else {517 moduleError = dispatchError.toHuman();518 }519 } else {520 this.logger.log(result, this.logger.level.ERROR);521 }522 }523524 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);525 unsub();526 reject({status, moduleError, result});527 }528 });529 } catch (e) {530 this.logger.log(e, this.logger.level.ERROR);531 reject(e);532 }533 });534 }535536 async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {537 const api = this.getApi();538 const signingInfo = await api.derive.tx.signingInfo(signer.address);539540 541 542 tx.sign(signer, {543 blockHash: api.genesisHash,544 genesisHash: api.genesisHash,545 runtimeVersion: api.runtimeVersion,546 nonce: signingInfo.nonce,547 });548549 if (len === null) {550 return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;551 } else {552 return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;553 }554 }555556 constructApiCall(apiCall: string, params: any[]) {557 if(this.api === null) throw Error('API not initialized');558 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);559 let call = this.getApi() as any;560 for(const part of apiCall.slice(4).split('.')) {561 call = call[part];562 }563 return call(...params);564 }565566 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null) {567 if(this.api === null) throw Error('API not initialized');568 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);569570 const startTime = (new Date()).getTime();571 let result: ITransactionResult;572 let events: IEvent[] = [];573 try {574 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;575 events = this.eventHelper.extractEvents(result.result.events);576 }577 catch(e) {578 if(!(e as object).hasOwnProperty('status')) throw e;579 result = e as ITransactionResult;580 }581582 const endTime = (new Date()).getTime();583584 const log = {585 executedAt: endTime,586 executionTime: endTime - startTime,587 type: this.chainLogType.EXTRINSIC,588 status: result.status,589 call: extrinsic,590 signer: this.getSignerAddress(sender),591 params,592 } as IUniqueHelperLog;593594 if(result.status !== this.transactionStatus.SUCCESS) {595 if (result.moduleError) log.moduleError = result.moduleError;596 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;597 }598 if(events.length > 0) log.events = events;599600 this.chainLog.push(log);601602 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {603 if (result.moduleError) throw Error(`${result.moduleError}`);604 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));605 }606 return result;607 }608609 async callRpc(rpc: string, params?: any[]) {610 if(typeof params === 'undefined') params = [];611 if(this.api === null) throw Error('API not initialized');612 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);613614 const startTime = (new Date()).getTime();615 let result;616 let error = null;617 const log = {618 type: this.chainLogType.RPC,619 call: rpc,620 params,621 } as IUniqueHelperLog;622623 try {624 result = await this.constructApiCall(rpc, params);625 }626 catch(e) {627 error = e;628 }629630 const endTime = (new Date()).getTime();631632 log.executedAt = endTime;633 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';634 log.executionTime = endTime - startTime;635636 this.chainLog.push(log);637638 if(error !== null) throw error;639640 return result;641 }642643 getSignerAddress(signer: IKeyringPair | string): string {644 if(typeof signer === 'string') return signer;645 return signer.address;646 }647648 fetchAllPalletNames(): string[] {649 if(this.api === null) throw Error('API not initialized');650 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());651 }652653 fetchMissingPalletNames(requiredPallets: string[]): string[] {654 const palletNames = this.fetchAllPalletNames();655 return requiredPallets.filter(p => !palletNames.includes(p));656 }657}658659660class HelperGroup<T extends ChainHelperBase> {661 helper: T;662663 constructor(uniqueHelper: T) {664 this.helper = uniqueHelper;665 }666}667668669class CollectionGroup extends HelperGroup<UniqueHelper> {670 671672673674675676677678679 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {680 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();681 }682683 684685686687688 async getTotalCount(): Promise<number> {689 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();690 }691692 693694695696697698699700701 async getData(collectionId: number): Promise<{702 id: number;703 name: string;704 description: string;705 tokensCount: number;706 admins: CrossAccountId[];707 normalizedOwner: TSubstrateAccount;708 raw: any709 } | null> {710 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);711 const humanCollection = collection.toHuman(), collectionData = {712 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],713 raw: humanCollection,714 } as any, jsonCollection = collection.toJSON();715 if (humanCollection === null) return null;716 collectionData.raw.limits = jsonCollection.limits;717 collectionData.raw.permissions = jsonCollection.permissions;718 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);719 for (const key of ['name', 'description']) {720 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);721 }722723 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))724 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)725 : 0;726 collectionData.admins = await this.getAdmins(collectionId);727728 return collectionData;729 }730731 732733734735736737738739 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {740 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();741742 return normalize743 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())744 : admins;745 }746747 748749750751752753754 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {755 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();756 return normalize757 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())758 : allowListed;759 }760761 762763764765766767768 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {769 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();770 }771772 773774775776777778779780 async burn(signer: TSigner, collectionId: number): Promise<boolean> {781 const result = await this.helper.executeExtrinsic(782 signer,783 'api.tx.unique.destroyCollection', [collectionId],784 true,785 );786787 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');788 }789790 791792793794795796797798799 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {800 const result = await this.helper.executeExtrinsic(801 signer,802 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],803 true,804 );805806 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorSet');807 }808809 810811812813814815816817 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {818 const result = await this.helper.executeExtrinsic(819 signer,820 'api.tx.unique.confirmSponsorship', [collectionId],821 true,822 );823824 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'SponsorshipConfirmed');825 }826827 828829830831832833834835 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {836 const result = await this.helper.executeExtrinsic(837 signer,838 'api.tx.unique.removeCollectionSponsor', [collectionId],839 true,840 );841842 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorRemoved');843 }844845 846847848849850851852853854855856857858859860861862 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {863 const result = await this.helper.executeExtrinsic(864 signer,865 'api.tx.unique.setCollectionLimits', [collectionId, limits],866 true,867 );868869 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionLimitSet');870 }871872 873874875876877878879880881 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {882 const result = await this.helper.executeExtrinsic(883 signer,884 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],885 true,886 );887888 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionOwnedChanged');889 }890891 892893894895896897898899900 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {901 const result = await this.helper.executeExtrinsic(902 signer,903 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],904 true,905 );906907 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminAdded');908 }909910 911912913914915916917918919 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {920 const result = await this.helper.executeExtrinsic(921 signer,922 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],923 true,924 );925926 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminRemoved');927 }928929 930931932933934935936937 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {938 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();939 }940941 942943944945946947948 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {949 const result = await this.helper.executeExtrinsic(950 signer,951 'api.tx.unique.addToAllowList', [collectionId, addressObj],952 true,953 );954955 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressAdded');956 }957958 959960961962963964965966 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {967 const result = await this.helper.executeExtrinsic(968 signer,969 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],970 true,971 );972973 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressRemoved');974 }975976 977978979980981982983984985 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {986 const result = await this.helper.executeExtrinsic(987 signer,988 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],989 true,990 );991992 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionPermissionSet');993 }994995 99699799899910001001100210031004 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1005 return await this.setPermissions(signer, collectionId, {nesting: permissions});1006 }10071008 10091010101110121013101410151016 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1017 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1018 }10191020 102110221023102410251026102710281029 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1030 const result = await this.helper.executeExtrinsic(1031 signer,1032 'api.tx.unique.setCollectionProperties', [collectionId, properties],1033 true,1034 );10351036 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1037 }10381039 10401041104210431044104510461047 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1048 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1049 }10501051 async getCollectionOptions(collectionId: number) {1052 return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1053 }10541055 105610571058105910601061106210631064 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1065 const result = await this.helper.executeExtrinsic(1066 signer,1067 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1068 true,1069 );10701071 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1072 }10731074 10751076107710781079108010811082108310841085 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1086 const result = await this.helper.executeExtrinsic(1087 signer,1088 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1089 true, 1090 );10911092 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1093 }10941095 1096109710981099110011011102110311041105110611071108 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1109 const result = await this.helper.executeExtrinsic(1110 signer,1111 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1112 true, 1113 );1114 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1115 }11161117 11181119112011211122112311241125112611271128 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1129 const burnResult = await this.helper.executeExtrinsic(1130 signer,1131 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1132 true, 1133 );1134 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1135 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1136 return burnedTokens.success;1137 }11381139 11401141114211431144114511461147114811491150 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1151 const burnResult = await this.helper.executeExtrinsic(1152 signer,1153 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1154 true, 1155 );1156 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1157 return burnedTokens.success && burnedTokens.tokens.length > 0;1158 }11591160 1161116211631164116511661167116811691170 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1171 const approveResult = await this.helper.executeExtrinsic(1172 signer,1173 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1174 true, 1175 );11761177 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1178 }11791180 1181118211831184118511861187118811891190 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1191 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1192 }11931194 1195119611971198119912001201 async getLastTokenId(collectionId: number): Promise<number> {1202 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1203 }12041205 12061207120812091210121112121213 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1214 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1215 }1216}12171218class NFTnRFT extends CollectionGroup {1219 12201221122212231224122512261227 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1228 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1229 }12301231 1232123312341235123612371238123912401241 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1242 properties: IProperty[];1243 owner: CrossAccountId;1244 normalizedOwner: CrossAccountId;1245 }| null> {1246 let tokenData;1247 if(typeof blockHashAt === 'undefined') {1248 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1249 }1250 else {1251 if(propertyKeys.length == 0) {1252 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1253 if(!collection) return null;1254 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1255 }1256 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1257 }1258 tokenData = tokenData.toHuman();1259 if (tokenData === null || tokenData.owner === null) return null;1260 const owner = {} as any;1261 for (const key of Object.keys(tokenData.owner)) {1262 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate' 1263 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key]) 1264 : tokenData.owner[key];1265 }1266 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1267 return tokenData;1268 }12691270 12711272127312741275127612771278127912801281 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1282 const result = await this.helper.executeExtrinsic(1283 signer,1284 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1285 true,1286 );12871288 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1289 }12901291 12921293129412951296129712981299 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1300 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1301 }13021303 1304130513061307130813091310131113121313 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1314 const result = await this.helper.executeExtrinsic(1315 signer,1316 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1317 true,1318 );13191320 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1321 }13221323 132413251326132713281329133013311332 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1333 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1334 }13351336 133713381339134013411342134313441345 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1346 const result = await this.helper.executeExtrinsic(1347 signer,1348 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1349 true,1350 );13511352 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1353 }13541355 135613571358135913601361136213631364 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1365 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; 1366 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1367 for (const key of ['name', 'description', 'tokenPrefix']) {1368 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);1369 }1370 const creationResult = await this.helper.executeExtrinsic(1371 signer,1372 'api.tx.unique.createCollectionEx', [collectionOptions],1373 true, 1374 );1375 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1376 }13771378 getCollectionObject(_collectionId: number): any {1379 return null;1380 }13811382 getTokenObject(_collectionId: number, _tokenId: number): any {1383 return null;1384 }1385}138613871388class NFTGroup extends NFTnRFT {1389 139013911392139313941395 getCollectionObject(collectionId: number): UniqueNFTCollection {1396 return new UniqueNFTCollection(collectionId, this.helper);1397 }13981399 1400140114021403140414051406 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1407 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1408 }14091410 14111412141314141415141614171418 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1419 let owner;1420 if (typeof blockHashAt === 'undefined') {1421 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1422 } else {1423 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1424 }1425 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1426 }14271428 1429143014311432143314341435 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1436 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1437 }14381439 1440144114421443144414451446144714481449 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1450 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1451 }14521453 145414551456145714581459146014611462146314641465 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1466 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1467 }14681469 14701471147214731474147514761477 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1478 let owner;1479 if (typeof blockHashAt === 'undefined') {1480 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1481 } else {1482 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1483 }14841485 if (owner === null) return null;14861487 return owner.toHuman();1488 }14891490 14911492149314941495149614971498 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1499 let children;1500 if(typeof blockHashAt === 'undefined') {1501 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1502 } else {1503 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1504 }15051506 return children.toJSON().map((x: any) => {1507 return {collectionId: x.collection, tokenId: x.token};1508 });1509 }15101511 15121513151415151516151715181519 async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1520 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1521 const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1522 if(!result) {1523 throw Error('Unable to nest token!');1524 }1525 return result;1526 }15271528 152915301531153215331534153515361537 async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1538 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1539 const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1540 if(!result) {1541 throw Error('Unable to unnest token!');1542 }1543 return result;1544 }15451546 154715481549155015511552155315541555155615571558 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1559 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1560 }15611562 156315641565156615671568 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1569 const creationResult = await this.helper.executeExtrinsic(1570 signer,1571 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1572 nft: {1573 properties: data.properties,1574 },1575 }],1576 true,1577 );1578 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1579 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1580 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1581 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1582 }15831584 158515861587158815891590159115921593159415951596159715981599 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1600 const creationResult = await this.helper.executeExtrinsic(1601 signer,1602 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1603 true,1604 );1605 const collection = this.getCollectionObject(collectionId);1606 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1607 }16081609 161016111612161316141615161616171618161916201621162216231624162516261627 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1628 const rawTokens = [];1629 for (const token of tokens) {1630 const raw = {NFT: {properties: token.properties}};1631 rawTokens.push(raw);1632 }1633 const creationResult = await this.helper.executeExtrinsic(1634 signer,1635 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1636 true,1637 );1638 const collection = this.getCollectionObject(collectionId);1639 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1640 }16411642 1643164416451646164716481649165016511652 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId) {1653 return super.approveToken(signer, collectionId, tokenId, toAddressObj, 1n);1654 }1655}165616571658class RFTGroup extends NFTnRFT {1659 166016611662166316641665 getCollectionObject(collectionId: number): UniqueRFTCollection {1666 return new UniqueRFTCollection(collectionId, this.helper);1667 }16681669 1670167116721673167416751676 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1677 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1678 }16791680 1681168216831684168516861687 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1688 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1689 }16901691 16921693169416951696169716981699 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1700 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1701 }17021703 1704170517061707170817091710171117121713 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1714 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1715 }17161717 17181719172017211722172317241725172617271728 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1729 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1730 }17311732 173317341735173617371738173917401741174217431744 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1745 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1746 }17471748 1749175017511752175317541755 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1756 const creationResult = await this.helper.executeExtrinsic(1757 signer,1758 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1759 refungible: {1760 pieces: data.pieces,1761 properties: data.properties,1762 },1763 }],1764 true,1765 );1766 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1767 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1768 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1769 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1770 }17711772 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1773 throw Error('Not implemented');1774 const creationResult = await this.helper.executeExtrinsic(1775 signer,1776 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1777 true, 1778 );1779 const collection = this.getCollectionObject(collectionId);1780 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1781 }17821783 178417851786178717881789179017911792 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1793 const rawTokens = [];1794 for (const token of tokens) {1795 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1796 rawTokens.push(raw);1797 }1798 const creationResult = await this.helper.executeExtrinsic(1799 signer,1800 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1801 true,1802 );1803 const collection = this.getCollectionObject(collectionId);1804 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1805 }18061807 180818091810181118121813181418151816 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1817 return await super.burnToken(signer, collectionId, tokenId, amount);1818 }18191820 1821182218231824182518261827182818291830 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1831 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1832 }18331834 18351836183718381839184018411842184318441845 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1846 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1847 }18481849 1850185118521853185418551856 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {1857 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();1858 }18591860 186118621863186418651866186718681869 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {1870 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);1871 const repartitionResult = await this.helper.executeExtrinsic(1872 signer,1873 'api.tx.unique.repartition', [collectionId, tokenId, amount],1874 true,1875 );1876 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');1877 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');1878 }1879}188018811882class FTGroup extends CollectionGroup {1883 188418851886188718881889 getCollectionObject(collectionId: number): UniqueFTCollection {1890 return new UniqueFTCollection(collectionId, this.helper);1891 }18921893 1894189518961897189818991900190119021903190419051906 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {1907 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; 1908 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');1909 collectionOptions.mode = {fungible: decimalPoints};1910 for (const key of ['name', 'description', 'tokenPrefix']) {1911 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);1912 }1913 const creationResult = await this.helper.executeExtrinsic(1914 signer,1915 'api.tx.unique.createCollectionEx', [collectionOptions],1916 true,1917 );1918 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1919 }19201921 192219231924192519261927192819291930 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {1931 const creationResult = await this.helper.executeExtrinsic(1932 signer,1933 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {1934 fungible: {1935 value: amount,1936 },1937 }],1938 true, 1939 );1940 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1941 }19421943 19441945194619471948194919501951 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {1952 const rawTokens = [];1953 for (const token of tokens) {1954 const raw = {Fungible: {Value: token.value}};1955 rawTokens.push(raw);1956 }1957 const creationResult = await this.helper.executeExtrinsic(1958 signer,1959 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1960 true,1961 );1962 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1963 }19641965 196619671968196919701971 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {1972 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1973 }19741975 1976197719781979198019811982 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {1983 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();1984 }19851986 198719881989199019911992199319941995 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {1996 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);1997 }19981999 2000200120022003200420052006200720082009 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2010 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2011 }20122013 20142015201620172018201920202021 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {2022 return await super.burnToken(signer, collectionId, 0, amount);2023 }20242025 202620272028202920302031203220332034 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {2035 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2036 }20372038 20392040204120422043 async getTotalPieces(collectionId: number): Promise<bigint> {2044 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2045 }20462047 2048204920502051205220532054205520562057 async approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2058 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2059 }20602061 2062206320642065206620672068 async getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2069 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2070 }2071}207220732074class ChainGroup extends HelperGroup<ChainHelperBase> {2075 20762077207820792080 getChainProperties(): IChainProperties {2081 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2082 return {2083 ss58Format: properties.ss58Format.toJSON(),2084 tokenDecimals: properties.tokenDecimals.toJSON(),2085 tokenSymbol: properties.tokenSymbol.toJSON(),2086 };2087 }20882089 20902091209220932094 async getLatestBlockNumber(): Promise<number> {2095 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2096 }20972098 209921002101210221032104 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2105 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2106 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2107 return blockHash;2108 }21092110 2111 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2112 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2113 if (!blockHash) return null;2114 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2115 }21162117 211821192120212121222123 async getNonce(address: TSubstrateAccount): Promise<number> {2124 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2125 }2126}21272128class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2129 213021312132213321342135 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2136 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2137 }21382139 21402141214221432144214521462147 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2148 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);21492150 let transfer = {from: null, to: null, amount: 0n} as any;2151 result.result.events.forEach(({event: {data, method, section}}) => {2152 if ((section === 'balances') && (method === 'Transfer')) {2153 transfer = {2154 from: this.helper.address.normalizeSubstrate(data[0]),2155 to: this.helper.address.normalizeSubstrate(data[1]),2156 amount: BigInt(data[2]),2157 };2158 }2159 });2160 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from 2161 && this.helper.address.normalizeSubstrate(address) === transfer.to 2162 && BigInt(amount) === transfer.amount;2163 return isSuccess;2164 }21652166 21672168216921702171 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2172 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2173 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2174 }2175}21762177class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2178 217921802181218221832184 async getEthereum(address: TEthereumAccount): Promise<bigint> {2185 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2186 }21872188 21892190219121922193219421952196 async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2197 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);21982199 let transfer = {from: null, to: null, amount: 0n} as any;2200 result.result.events.forEach(({event: {data, method, section}}) => {2201 if ((section === 'balances') && (method === 'Transfer')) {2202 transfer = {2203 from: data[0].toString(),2204 to: data[1].toString(),2205 amount: BigInt(data[2]),2206 };2207 }2208 });2209 const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from 2210 && address === transfer.to 2211 && BigInt(amount) === transfer.amount;2212 return isSuccess;2213 }2214}22152216class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2217 subBalanceGroup: SubstrateBalanceGroup<T>;2218 ethBalanceGroup: EthereumBalanceGroup<T>;22192220 constructor(helper: T) {2221 super(helper);2222 this.subBalanceGroup = new SubstrateBalanceGroup(helper);2223 this.ethBalanceGroup = new EthereumBalanceGroup(helper);2224 }22252226 getCollectionCreationPrice(): bigint {2227 return 2n * this.getOneTokenNominal();2228 }2229 22302231223222332234 getOneTokenNominal(): bigint {2235 const chainProperties = this.helper.chain.getChainProperties();2236 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2237 }22382239 224022412242224322442245 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2246 return this.subBalanceGroup.getSubstrate(address);2247 }22482249 22502251225222532254 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2255 return this.subBalanceGroup.getSubstrateFull(address);2256 }22572258 225922602261226222632264 async getEthereum(address: TEthereumAccount): Promise<bigint> {2265 return this.ethBalanceGroup.getEthereum(address);2266 }22672268 22692270227122722273227422752276 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2277 return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2278 }22792280 async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2281 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);22822283 let transfer = {from: null, to: null, amount: 0n} as any;2284 result.result.events.forEach(({event: {data, method, section}}) => {2285 if ((section === 'balances') && (method === 'Transfer')) {2286 transfer = {2287 from: this.helper.address.normalizeSubstrate(data[0]),2288 to: this.helper.address.normalizeSubstrate(data[1]),2289 amount: BigInt(data[2]),2290 };2291 }2292 });2293 let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2294 isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2295 isSuccess = isSuccess && BigInt(amount) === transfer.amount;2296 return isSuccess;2297 }2298}22992300class AddressGroup extends HelperGroup<ChainHelperBase> {2301 2302230323042305230623072308 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2309 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2310 }23112312 231323142315231623172318 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2319 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2320 }23212322 2323232423252326232723282329 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2330 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2331 }23322333 233423352336233723382339 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2340 return CrossAccountId.translateSubToEth(subAddress);2341 }23422343 paraSiblingSovereignAccount(paraid: number) {2344 2345 2346 const siblingPrefix = '0x7369626c';23472348 const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2349 const suffix = '000000000000000000000000000000000000000000000000';23502351 return siblingPrefix + encodedParaId + suffix;2352 }2353}23542355class StakingGroup extends HelperGroup<UniqueHelper> {2356 2357235823592360236123622363 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2364 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2365 const _stakeResult = await this.helper.executeExtrinsic(2366 signer, 'api.tx.appPromotion.stake',2367 [amountToStake], true,2368 );2369 2370 return true;2371 }23722373 2374237523762377237823792380 async unstake(signer: TSigner, label?: string): Promise<number> {2381 if(typeof label === 'undefined') label = `${signer.address}`;2382 const _unstakeResult = await this.helper.executeExtrinsic(2383 signer, 'api.tx.appPromotion.unstake',2384 [], true,2385 );2386 2387 return 1;2388 }23892390 23912392239323942395 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2396 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2397 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2398 }23992400 24012402240324042405 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2406 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2407 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2408 return { 2409 block: block.toBigInt(),2410 amount: amount.toBigInt(),2411 };2412 });2413 }24142415 24162417241824192420 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2421 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2422 }24232424 24252426242724282429 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2430 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2431 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2432 return {2433 block: block.toBigInt(),2434 amount: amount.toBigInt(),2435 };2436 });2437 return result;2438 }2439}24402441class SchedulerGroup extends HelperGroup<UniqueHelper> {2442 async cancelScheduled(signer: TSigner, scheduledId: string) {2443 return this.helper.executeExtrinsic(2444 signer,2445 'api.tx.scheduler.cancelNamed',2446 [scheduledId],2447 true,2448 );2449 }24502451 async changePriority(signer: TSigner, scheduledId: string, priority: number) {2452 return this.helper.executeExtrinsic(2453 signer,2454 'api.tx.scheduler.changeNamedPriority',2455 [scheduledId, priority],2456 true,2457 );2458 }24592460 scheduleAt<T extends UniqueHelper>(2461 scheduledId: string,2462 executionBlockNumber: number,2463 options: ISchedulerOptions = {},2464 ) {2465 return this.schedule<T>('scheduleNamed', scheduledId, executionBlockNumber, options);2466 }24672468 scheduleAfter<T extends UniqueHelper>(2469 scheduledId: string,2470 blocksBeforeExecution: number,2471 options: ISchedulerOptions = {},2472 ) {2473 return this.schedule<T>('scheduleNamedAfter', scheduledId, blocksBeforeExecution, options);2474 }24752476 schedule<T extends UniqueHelper>(2477 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter',2478 scheduledId: string,2479 blocksNum: number,2480 options: ISchedulerOptions = {},2481 ) {2482 2483 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2484 return this.helper.clone(ScheduledHelperType, {2485 scheduleFn,2486 scheduledId,2487 blocksNum,2488 options,2489 }) as T;2490 }2491}24922493class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2494 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2495 await this.helper.executeExtrinsic(2496 signer,2497 'api.tx.foreignAssets.registerForeignAsset',2498 [ownerAddress, location, metadata],2499 true,2500 );2501 }25022503 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2504 await this.helper.executeExtrinsic(2505 signer,2506 'api.tx.foreignAssets.updateForeignAsset',2507 [foreignAssetId, location, metadata],2508 true,2509 );2510 }2511}25122513class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2514 palletName: string;25152516 constructor(helper: T, palletName: string) {2517 super(helper);25182519 this.palletName = palletName;2520 }25212522 async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: number) {2523 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, {Limited: weightLimit}], true);2524 }2525}25262527class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2528 async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: number) {2529 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);2530 }25312532 async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: number) {2533 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);2534 }25352536 async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: number) {2537 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);2538 }2539}25402541class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2542 async accounts(address: string, currencyId: any) {2543 const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;2544 return BigInt(free);2545 }2546}25472548class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {2549 async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {2550 await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);2551 }25522553 async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {2554 await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);2555 }25562557 async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {2558 await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);2559 }25602561 async account(assetId: string | number, address: string) {2562 const accountAsset = (2563 await this.helper.callRpc('api.query.assets.account', [assetId, address])2564 ).toJSON()! as any;25652566 if (accountAsset !== null) {2567 return BigInt(accountAsset['balance']);2568 } else {2569 return null;2570 }2571 }2572}25732574class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {2575 async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {2576 await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);2577 }2578}25792580class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {2581 makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {2582 const apiPrefix = 'api.tx.assetManager.';25832584 const registerTx = this.helper.constructApiCall(2585 apiPrefix + 'registerForeignAsset',2586 [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],2587 );25882589 const setUnitsTx = this.helper.constructApiCall(2590 apiPrefix + 'setAssetUnitsPerSecond',2591 [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],2592 );25932594 const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);2595 const encodedProposal = batchCall?.method.toHex() || '';2596 return encodedProposal;2597 }25982599 async assetTypeId(location: any) {2600 return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);2601 }2602}26032604class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {2605 async notePreimage(signer: TSigner, encodedProposal: string) {2606 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.notePreimage', [encodedProposal], true);2607 }26082609 externalProposeMajority(proposalHash: string) {2610 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposalHash]);2611 }26122613 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {2614 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);2615 }26162617 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {2618 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);2619 }2620}26212622class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {2623 collective: string;26242625 constructor(helper: MoonbeamHelper, collective: string) {2626 super(helper);26272628 this.collective = collective;2629 }26302631 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {2632 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);2633 }26342635 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {2636 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);2637 }26382639 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: number, lengthBound: number) {2640 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);2641 }26422643 async proposalCount() {2644 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));2645 }2646}26472648export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;2649export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;26502651export class UniqueHelper extends ChainHelperBase {2652 balance: BalanceGroup<UniqueHelper>;2653 collection: CollectionGroup;2654 nft: NFTGroup;2655 rft: RFTGroup;2656 ft: FTGroup;2657 staking: StakingGroup;2658 scheduler: SchedulerGroup;2659 foreignAssets: ForeignAssetsGroup;2660 xcm: XcmGroup<UniqueHelper>;2661 xTokens: XTokensGroup<UniqueHelper>;2662 tokens: TokensGroup<UniqueHelper>;26632664 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2665 super(logger, options.helperBase ?? UniqueHelper);26662667 this.balance = new BalanceGroup(this);2668 this.collection = new CollectionGroup(this);2669 this.nft = new NFTGroup(this);2670 this.rft = new RFTGroup(this);2671 this.ft = new FTGroup(this);2672 this.staking = new StakingGroup(this);2673 this.scheduler = new SchedulerGroup(this);2674 this.foreignAssets = new ForeignAssetsGroup(this);2675 this.xcm = new XcmGroup(this, 'polkadotXcm');2676 this.xTokens = new XTokensGroup(this);2677 this.tokens = new TokensGroup(this);2678 }26792680 getSudo<T extends UniqueHelper>() {2681 2682 const SudoHelperType = SudoHelper(this.helperBase);2683 return this.clone(SudoHelperType) as T;2684 }2685}26862687export class XcmChainHelper extends ChainHelperBase {2688 async connect(wsEndpoint: string, _listeners?: any): Promise<void> {2689 const wsProvider = new WsProvider(wsEndpoint);2690 this.api = new ApiPromise({2691 provider: wsProvider,2692 });2693 await this.api.isReadyOrError;2694 this.network = await UniqueHelper.detectNetwork(this.api);2695 }2696}26972698export class RelayHelper extends XcmChainHelper {2699 xcm: XcmGroup<RelayHelper>;27002701 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2702 super(logger, options.helperBase ?? RelayHelper);27032704 this.xcm = new XcmGroup(this, 'xcmPallet');2705 }2706}27072708export class WestmintHelper extends XcmChainHelper {2709 balance: SubstrateBalanceGroup<WestmintHelper>;2710 xcm: XcmGroup<WestmintHelper>;2711 assets: AssetsGroup<WestmintHelper>;2712 xTokens: XTokensGroup<WestmintHelper>;27132714 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2715 super(logger, options.helperBase ?? WestmintHelper);27162717 this.balance = new SubstrateBalanceGroup(this);2718 this.xcm = new XcmGroup(this, 'polkadotXcm');2719 this.assets = new AssetsGroup(this);2720 this.xTokens = new XTokensGroup(this);2721 }2722}27232724export class MoonbeamHelper extends XcmChainHelper {2725 balance: EthereumBalanceGroup<MoonbeamHelper>;2726 assetManager: MoonbeamAssetManagerGroup;2727 assets: AssetsGroup<MoonbeamHelper>;2728 xTokens: XTokensGroup<MoonbeamHelper>;2729 democracy: MoonbeamDemocracyGroup;2730 collective: {2731 council: MoonbeamCollectiveGroup,2732 techCommittee: MoonbeamCollectiveGroup,2733 };27342735 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2736 super(logger, options.helperBase ?? MoonbeamHelper);27372738 this.balance = new EthereumBalanceGroup(this);2739 this.assetManager = new MoonbeamAssetManagerGroup(this);2740 this.assets = new AssetsGroup(this);2741 this.xTokens = new XTokensGroup(this);2742 this.democracy = new MoonbeamDemocracyGroup(this);2743 this.collective = {2744 council: new MoonbeamCollectiveGroup(this, 'councilCollective'),2745 techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),2746 };2747 }2748}27492750export class AcalaHelper extends XcmChainHelper {2751 balance: SubstrateBalanceGroup<AcalaHelper>;2752 assetRegistry: AcalaAssetRegistryGroup;2753 xTokens: XTokensGroup<AcalaHelper>;2754 tokens: TokensGroup<AcalaHelper>;27552756 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2757 super(logger, options.helperBase ?? AcalaHelper);27582759 this.balance = new SubstrateBalanceGroup(this);2760 this.assetRegistry = new AcalaAssetRegistryGroup(this);2761 this.xTokens = new XTokensGroup(this);2762 this.tokens = new TokensGroup(this);2763 }27642765 getSudo<T extends AcalaHelper>() {2766 2767 const SudoHelperType = SudoHelper(this.helperBase);2768 return this.clone(SudoHelperType) as T;2769 }2770}277127722773function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {2774 return class extends Base {2775 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter';2776 scheduledId: string;2777 blocksNum: number;2778 options: ISchedulerOptions;27792780 constructor(...args: any[]) {2781 const logger = args[0] as ILogger;2782 const options = args[1] as {2783 scheduleFn: 'scheduleNamed' | 'scheduleNamedAfter',2784 scheduledId: string,2785 blocksNum: number,2786 options: ISchedulerOptions2787 };27882789 super(logger);27902791 this.scheduleFn = options.scheduleFn;2792 this.scheduledId = options.scheduledId;2793 this.blocksNum = options.blocksNum;2794 this.options = options.options;2795 }27962797 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {2798 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);2799 const extrinsic = 'api.tx.scheduler.' + this.scheduleFn;28002801 return super.executeExtrinsic(2802 sender,2803 extrinsic,2804 [2805 this.scheduledId,2806 this.blocksNum,2807 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,2808 this.options.priority ?? null,2809 {Value: scheduledTx},2810 ],2811 expectSuccess,2812 );2813 }2814 };2815}281628172818function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {2819 return class extends Base {2820 constructor(...args: any[]) {2821 super(...args);2822 }28232824 executeExtrinsic (2825 sender: IKeyringPair,2826 extrinsic: string,2827 params: any[],2828 expectSuccess?: boolean,2829 ): Promise<ITransactionResult> {2830 const call = this.constructApiCall(extrinsic, params);28312832 return super.executeExtrinsic(2833 sender,2834 'api.tx.sudo.sudo',2835 [call],2836 expectSuccess,2837 );2838 }2839 };2840}28412842export class UniqueBaseCollection {2843 helper: UniqueHelper;2844 collectionId: number;28452846 constructor(collectionId: number, uniqueHelper: UniqueHelper) {2847 this.collectionId = collectionId;2848 this.helper = uniqueHelper;2849 }28502851 async getData() {2852 return await this.helper.collection.getData(this.collectionId);2853 }28542855 async getLastTokenId() {2856 return await this.helper.collection.getLastTokenId(this.collectionId);2857 }28582859 async doesTokenExist(tokenId: number) {2860 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);2861 }28622863 async getAdmins() {2864 return await this.helper.collection.getAdmins(this.collectionId);2865 }28662867 async getAllowList() {2868 return await this.helper.collection.getAllowList(this.collectionId);2869 }28702871 async getEffectiveLimits() {2872 return await this.helper.collection.getEffectiveLimits(this.collectionId);2873 }28742875 async getProperties(propertyKeys?: string[] | null) {2876 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);2877 }28782879 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {2880 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);2881 }28822883 async getOptions() {2884 return await this.helper.collection.getCollectionOptions(this.collectionId);2885 }28862887 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {2888 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);2889 }28902891 async confirmSponsorship(signer: TSigner) {2892 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);2893 }28942895 async removeSponsor(signer: TSigner) {2896 return await this.helper.collection.removeSponsor(signer, this.collectionId);2897 }28982899 async setLimits(signer: TSigner, limits: ICollectionLimits) {2900 return await this.helper.collection.setLimits(signer, this.collectionId, limits);2901 }29022903 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {2904 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);2905 }29062907 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2908 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);2909 }29102911 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {2912 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);2913 }29142915 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {2916 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);2917 }29182919 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2920 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);2921 }29222923 async setProperties(signer: TSigner, properties: IProperty[]) {2924 return await this.helper.collection.setProperties(signer, this.collectionId, properties);2925 }29262927 async deleteProperties(signer: TSigner, propertyKeys: string[]) {2928 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);2929 }29302931 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {2932 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);2933 }29342935 async enableNesting(signer: TSigner, permissions: INestingPermissions) {2936 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);2937 }29382939 async disableNesting(signer: TSigner) {2940 return await this.helper.collection.disableNesting(signer, this.collectionId);2941 }29422943 async burn(signer: TSigner) {2944 return await this.helper.collection.burn(signer, this.collectionId);2945 }29462947 scheduleAt<T extends UniqueHelper>(2948 scheduledId: string,2949 executionBlockNumber: number,2950 options: ISchedulerOptions = {},2951 ) {2952 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);2953 return new UniqueBaseCollection(this.collectionId, scheduledHelper);2954 }29552956 scheduleAfter<T extends UniqueHelper>(2957 scheduledId: string,2958 blocksBeforeExecution: number,2959 options: ISchedulerOptions = {},2960 ) {2961 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);2962 return new UniqueBaseCollection(this.collectionId, scheduledHelper);2963 }29642965 getSudo<T extends UniqueHelper>() {2966 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());2967 }29682969 getSudo() {2970 return new UniqueCollectionBase(this.collectionId, this.helper.getSudo());2971 }2972}297329742975export class UniqueNFTCollection extends UniqueBaseCollection {2976 getTokenObject(tokenId: number) {2977 return new UniqueNFToken(tokenId, this);2978 }29792980 async getTokensByAddress(addressObj: ICrossAccountId) {2981 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);2982 }29832984 async getToken(tokenId: number, blockHashAt?: string) {2985 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);2986 }29872988 async getTokenOwner(tokenId: number, blockHashAt?: string) {2989 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);2990 }29912992 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {2993 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);2994 }29952996 async getTokenChildren(tokenId: number, blockHashAt?: string) {2997 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);2998 }29993000 async getPropertyPermissions(propertyKeys: string[] | null = null) {3001 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);3002 }30033004 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3005 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3006 }30073008 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {3009 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);3010 }30113012 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3013 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);3014 }30153016 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {3017 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);3018 }30193020 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {3021 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);3022 }30233024 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3025 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});3026 }30273028 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {3029 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);3030 }30313032 async burnToken(signer: TSigner, tokenId: number) {3033 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);3034 }30353036 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {3037 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);3038 }30393040 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3041 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);3042 }30433044 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3045 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3046 }30473048 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3049 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3050 }30513052 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3053 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3054 }30553056 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3057 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3058 }30593060 scheduleAt<T extends UniqueHelper>(3061 scheduledId: string,3062 executionBlockNumber: number,3063 options: ISchedulerOptions = {},3064 ) {3065 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);3066 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3067 }30683069 scheduleAfter<T extends UniqueHelper>(3070 scheduledId: string,3071 blocksBeforeExecution: number,3072 options: ISchedulerOptions = {},3073 ) {3074 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3075 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3076 }30773078 getSudo<T extends UniqueHelper>() {3079 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());3080 }3081}308230833084export class UniqueRFTCollection extends UniqueBaseCollection {3085 getTokenObject(tokenId: number) {3086 return new UniqueRFToken(tokenId, this);3087 }30883089 async getToken(tokenId: number, blockHashAt?: string) {3090 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);3091 }30923093 async getTokensByAddress(addressObj: ICrossAccountId) {3094 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);3095 }30963097 async getTop10TokenOwners(tokenId: number) {3098 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);3099 }31003101 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {3102 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3103 }31043105 async getTokenTotalPieces(tokenId: number) {3106 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3107 }31083109 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3110 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3111 }31123113 async getPropertyPermissions(propertyKeys: string[] | null = null) {3114 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3115 }31163117 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3118 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3119 }31203121 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3122 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3123 }31243125 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3126 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3127 }31283129 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3130 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3131 }31323133 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3134 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3135 }31363137 async mintToken(signer: TSigner, pieces=1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3138 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3139 }31403141 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3142 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3143 }31443145 async burnToken(signer: TSigner, tokenId: number, amount=1n) {3146 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3147 }31483149 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {3150 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3151 }31523153 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3154 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3155 }31563157 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3158 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3159 }31603161 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3162 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3163 }31643165 scheduleAt<T extends UniqueHelper>(3166 scheduledId: string,3167 executionBlockNumber: number,3168 options: ISchedulerOptions = {},3169 ) {3170 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);3171 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3172 }31733174 scheduleAfter<T extends UniqueHelper>(3175 scheduledId: string,3176 blocksBeforeExecution: number,3177 options: ISchedulerOptions = {},3178 ) {3179 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3180 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3181 }31823183 getSudo<T extends UniqueHelper>() {3184 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3185 }3186}318731883189export class UniqueFTCollection extends UniqueBaseCollection {3190 async getBalance(addressObj: ICrossAccountId) {3191 return await this.helper.ft.getBalance(this.collectionId, addressObj);3192 }31933194 async getTotalPieces() {3195 return await this.helper.ft.getTotalPieces(this.collectionId);3196 }31973198 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3199 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3200 }32013202 async getTop10Owners() {3203 return await this.helper.ft.getTop10Owners(this.collectionId);3204 }32053206 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3207 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3208 }32093210 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3211 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3212 }32133214 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3215 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3216 }32173218 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3219 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3220 }32213222 async burnTokens(signer: TSigner, amount=1n) {3223 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3224 }32253226 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3227 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3228 }32293230 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3231 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3232 }32333234 scheduleAt<T extends UniqueHelper>(3235 scheduledId: string,3236 executionBlockNumber: number,3237 options: ISchedulerOptions = {},3238 ) {3239 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(scheduledId, executionBlockNumber, options);3240 return new UniqueFTCollection(this.collectionId, scheduledHelper);3241 }32423243 scheduleAfter<T extends UniqueHelper>(3244 scheduledId: string,3245 blocksBeforeExecution: number,3246 options: ISchedulerOptions = {},3247 ) {3248 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3249 return new UniqueFTCollection(this.collectionId, scheduledHelper);3250 }32513252 getSudo<T extends UniqueHelper>() {3253 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3254 }3255}325632573258export class UniqueBaseToken {3259 collection: UniqueNFTCollection | UniqueRFTCollection;3260 collectionId: number;3261 tokenId: number;32623263 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3264 this.collection = collection;3265 this.collectionId = collection.collectionId;3266 this.tokenId = tokenId;3267 }32683269 async getNextSponsored(addressObj: ICrossAccountId) {3270 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3271 }32723273 async getProperties(propertyKeys?: string[] | null) {3274 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3275 }32763277 async setProperties(signer: TSigner, properties: IProperty[]) {3278 return await this.collection.setTokenProperties(signer, this.tokenId, properties);3279 }32803281 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3282 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3283 }32843285 async doesExist() {3286 return await this.collection.doesTokenExist(this.tokenId);3287 }32883289 nestingAccount() {3290 return this.collection.helper.util.getTokenAccount(this);3291 }32923293 scheduleAt<T extends UniqueHelper>(3294 scheduledId: string,3295 executionBlockNumber: number,3296 options: ISchedulerOptions = {},3297 ) {3298 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);3299 return new UniqueBaseToken(this.tokenId, scheduledCollection);3300 }33013302 scheduleAfter<T extends UniqueHelper>(3303 scheduledId: string,3304 blocksBeforeExecution: number,3305 options: ISchedulerOptions = {},3306 ) {3307 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3308 return new UniqueBaseToken(this.tokenId, scheduledCollection);3309 }33103311 getSudo<T extends UniqueHelper>() {3312 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3313 }3314}331533163317export class UniqueNFToken extends UniqueBaseToken {3318 collection: UniqueNFTCollection;33193320 constructor(tokenId: number, collection: UniqueNFTCollection) {3321 super(tokenId, collection);3322 this.collection = collection;3323 }33243325 async getData(blockHashAt?: string) {3326 return await this.collection.getToken(this.tokenId, blockHashAt);3327 }33283329 async getOwner(blockHashAt?: string) {3330 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3331 }33323333 async getTopmostOwner(blockHashAt?: string) {3334 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3335 }33363337 async getChildren(blockHashAt?: string) {3338 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3339 }33403341 async nest(signer: TSigner, toTokenObj: IToken) {3342 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3343 }33443345 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3346 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3347 }33483349 async transfer(signer: TSigner, addressObj: ICrossAccountId) {3350 return await this.collection.transferToken(signer, this.tokenId, addressObj);3351 }33523353 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3354 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3355 }33563357 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3358 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3359 }33603361 async isApproved(toAddressObj: ICrossAccountId) {3362 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3363 }33643365 async burn(signer: TSigner) {3366 return await this.collection.burnToken(signer, this.tokenId);3367 }33683369 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3370 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3371 }33723373 scheduleAt<T extends UniqueHelper>(3374 scheduledId: string,3375 executionBlockNumber: number,3376 options: ISchedulerOptions = {},3377 ) {3378 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);3379 return new UniqueNFToken(this.tokenId, scheduledCollection);3380 }33813382 scheduleAfter<T extends UniqueHelper>(3383 scheduledId: string,3384 blocksBeforeExecution: number,3385 options: ISchedulerOptions = {},3386 ) {3387 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3388 return new UniqueNFToken(this.tokenId, scheduledCollection);3389 }33903391 getSudo<T extends UniqueHelper>() {3392 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3393 }3394}33953396export class UniqueRFToken extends UniqueBaseToken {3397 collection: UniqueRFTCollection;33983399 constructor(tokenId: number, collection: UniqueRFTCollection) {3400 super(tokenId, collection);3401 this.collection = collection;3402 }34033404 async getData(blockHashAt?: string) {3405 return await this.collection.getToken(this.tokenId, blockHashAt);3406 }34073408 async getTop10Owners() {3409 return await this.collection.getTop10TokenOwners(this.tokenId);3410 }34113412 async getBalance(addressObj: ICrossAccountId) {3413 return await this.collection.getTokenBalance(this.tokenId, addressObj);3414 }34153416 async getTotalPieces() {3417 return await this.collection.getTokenTotalPieces(this.tokenId);3418 }34193420 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {3421 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);3422 }34233424 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {3425 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);3426 }34273428 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3429 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);3430 }34313432 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3433 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);3434 }34353436 async repartition(signer: TSigner, amount: bigint) {3437 return await this.collection.repartitionToken(signer, this.tokenId, amount);3438 }34393440 async burn(signer: TSigner, amount=1n) {3441 return await this.collection.burnToken(signer, this.tokenId, amount);3442 }34433444 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3445 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);3446 }34473448 scheduleAt<T extends UniqueHelper>(3449 scheduledId: string,3450 executionBlockNumber: number,3451 options: ISchedulerOptions = {},3452 ) {3453 const scheduledCollection = this.collection.scheduleAt<T>(scheduledId, executionBlockNumber, options);3454 return new UniqueRFToken(this.tokenId, scheduledCollection);3455 }34563457 scheduleAfter<T extends UniqueHelper>(3458 scheduledId: string,3459 blocksBeforeExecution: number,3460 options: ISchedulerOptions = {},3461 ) {3462 const scheduledCollection = this.collection.scheduleAfter<T>(scheduledId, blocksBeforeExecution, options);3463 return new UniqueRFToken(this.tokenId, scheduledCollection);3464 }34653466 getSudo<T extends UniqueHelper>() {3467 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());3468 }3469}