git.delta.rocks / unique-network / refs/commits / 77e366b9e580

difftreelog

tests(nesting): revert majority of last commit + refactor token and collection naming convention

Fahrrader2022-09-27parent: #415e2e0.patch.diff
in: master

6 files changed

modifiedtests/src/fungible.test.tsdiffbeforeafterboth
--- a/tests/src/fungible.test.ts
+++ b/tests/src/fungible.test.ts
@@ -15,7 +15,9 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import {itSub, usingPlaygrounds, expect, U128_MAX} from './util/playgrounds';
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
+
+const U128_MAX = (1n << 128n) - 1n;
 
 describe('integration test: Fungible functionality:', () => {
   let alice: IKeyringPair;
modifiedtests/src/nesting/graphs.test.tsdiffbeforeafterboth
--- a/tests/src/nesting/graphs.test.ts
+++ b/tests/src/nesting/graphs.test.ts
@@ -16,8 +16,7 @@
 
 import {IKeyringPair} from '@polkadot/types/types';
 import {expect, itSub, usingPlaygrounds} from '../util/playgrounds';
-import {ITokenNonfungible} from '../util/playgrounds/types';
-import {UniqueHelper} from '../util/playgrounds/unique';
+import {UniqueHelper, UniqueNFToken} from '../util/playgrounds/unique';
 
 /**
  * ```dot
@@ -26,7 +25,7 @@
  * 8 -> 5
  * ```
  */
-async function buildComplexObjectGraph(helper: UniqueHelper, sender: IKeyringPair): Promise<ITokenNonfungible[]> {
+async function buildComplexObjectGraph(helper: UniqueHelper, sender: IKeyringPair): Promise<UniqueNFToken[]> {
   const collection = await helper.nft.mintCollection(sender, {permissions: {nesting: {tokenOwner: true}}});
   const tokens = await collection.mintMultipleTokens(sender, Array(8).fill({owner: {Substrate: sender.address}}));
modifiedtests/src/nesting/properties.test.tsdiffbeforeafterboth
1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds, expect} from '../util/playgrounds';18import {itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds, expect} from '../util/playgrounds';
19import {ICollectionBase, ICollectionNFT, ITokenNonfungible, ICollectionRFT, ITokenRefungible} from '../util/playgrounds/types';19import {UniqueHelper, UniqueBaseCollection, UniqueNFTCollection, UniqueNFToken, UniqueRFTCollection, UniqueRFToken} from '../util/playgrounds/unique';
20import {UniqueHelper} from '../util/playgrounds/unique';
2120
22// ---------- COLLECTION PROPERTIES21// ---------- COLLECTION PROPERTIES
2322
37    expect(await collection.getProperties()).to.be.empty;36    expect(await collection.getProperties()).to.be.empty;
38  });37  });
3938
40  async function testSetsPropertiesForCollection(collection: ICollectionBase) {39  async function testSetsPropertiesForCollection(collection: UniqueBaseCollection) {
41    // As owner40    // As owner
42    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}])).to.be.fulfilled;41    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}])).to.be.fulfilled;
4342
61    await testSetsPropertiesForCollection(await helper.rft.mintCollection(alice));60    await testSetsPropertiesForCollection(await helper.rft.mintCollection(alice));
62  });61  });
6362
64  async function testCheckValidNames(collection: ICollectionBase) {63  async function testCheckValidNames(collection: UniqueBaseCollection) {
65    // alpha symbols64    // alpha symbols
66    await expect(collection.setProperties(alice, [{key: 'answer'}])).to.be.fulfilled;65    await expect(collection.setProperties(alice, [{key: 'answer'}])).to.be.fulfilled;
6766
95    await testCheckValidNames(await helper.rft.mintCollection(alice));94    await testCheckValidNames(await helper.rft.mintCollection(alice));
96  });95  });
9796
98  async function testChangesProperties(collection: ICollectionBase) {97  async function testChangesProperties(collection: UniqueBaseCollection) {
99    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: ''}])).to.be.fulfilled;98    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: ''}])).to.be.fulfilled;
10099
101    // Mutate the properties100    // Mutate the properties
116    await testChangesProperties(await helper.rft.mintCollection(alice));115    await testChangesProperties(await helper.rft.mintCollection(alice));
117  });116  });
118117
119  async function testDeleteProperties(collection: ICollectionBase) {118  async function testDeleteProperties(collection: UniqueBaseCollection) {
120    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;119    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;
121120
122    await expect(collection.deleteProperties(alice, ['electron'])).to.be.fulfilled;121    await expect(collection.deleteProperties(alice, ['electron'])).to.be.fulfilled;
147    });146    });
148  });147  });
149  148  
150  async function testFailsSetPropertiesIfNotOwnerOrAdmin(collection: ICollectionBase) {  149  async function testFailsSetPropertiesIfNotOwnerOrAdmin(collection: UniqueBaseCollection) {  
151    await expect(collection.setProperties(bob, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]))150    await expect(collection.setProperties(bob, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]))
152      .to.be.rejectedWith(/common\.NoPermission/);151      .to.be.rejectedWith(/common\.NoPermission/);
153152
162    await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.rft.mintCollection(alice));161    await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.rft.mintCollection(alice));
163  });162  });
164  163  
165  async function testFailsSetPropertiesThatExeedLimits(collection: ICollectionBase) {164  async function testFailsSetPropertiesThatExeedLimits(collection: UniqueBaseCollection) {
166    const spaceLimit = (await (collection.helper!.api! as any).query.common.collectionProperties(collection.collectionId)).spaceLimit.toNumber();165    const spaceLimit = (await (collection.helper!.api! as any).query.common.collectionProperties(collection.collectionId)).spaceLimit.toNumber();
167  166  
168    // Mute the general tx parsing error, too many bytes to process167    // Mute the general tx parsing error, too many bytes to process
191    await testFailsSetPropertiesThatExeedLimits(await helper.rft.mintCollection(alice));190    await testFailsSetPropertiesThatExeedLimits(await helper.rft.mintCollection(alice));
192  });191  });
193  192  
194  async function testFailsSetMorePropertiesThanAllowed(collection: ICollectionBase) {193  async function testFailsSetMorePropertiesThanAllowed(collection: UniqueBaseCollection) {
195    const propertiesToBeSet = [];194    const propertiesToBeSet = [];
196    for (let i = 0; i < 65; i++) {195    for (let i = 0; i < 65; i++) {
197      propertiesToBeSet.push({196      propertiesToBeSet.push({
214    await testFailsSetMorePropertiesThanAllowed(await helper.rft.mintCollection(alice));213    await testFailsSetMorePropertiesThanAllowed(await helper.rft.mintCollection(alice));
215  });214  });
216  215  
217  async function testFailsSetPropertiesWithInvalidNames(collection: ICollectionBase) {216  async function testFailsSetPropertiesWithInvalidNames(collection: UniqueBaseCollection) {
218    const invalidProperties = [217    const invalidProperties = [
219      [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],218      [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],
220      [{key: 'Mr/Sandman', value: 'Bring me a gene'}],219      [{key: 'Mr/Sandman', value: 'Bring me a gene'}],
281    expect(propertyRights).to.be.empty;280    expect(propertyRights).to.be.empty;
282  });281  });
283  282  
284  async function testSetsAccessRightsToProperties(collection: ICollectionNFT | ICollectionRFT) {  283  async function testSetsAccessRightsToProperties(collection: UniqueNFTCollection | UniqueRFTCollection) {  
285    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true}}]))284    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true}}]))
286      .to.be.fulfilled;285      .to.be.fulfilled;
287286
305    await testSetsAccessRightsToProperties(await helper.rft.mintCollection(alice));304    await testSetsAccessRightsToProperties(await helper.rft.mintCollection(alice));
306  });305  });
307  306  
308  async function testChangesAccessRightsToProperty(collection: ICollectionNFT | ICollectionRFT) {307  async function testChangesAccessRightsToProperty(collection: UniqueNFTCollection | UniqueRFTCollection) {
309    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]))308    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]))
310      .to.be.fulfilled;309      .to.be.fulfilled;
311310
338    });337    });
339  });338  });
340339
341  async function testPreventsFromSettingAccessRightsNotAdminOrOwner(collection: ICollectionNFT | ICollectionRFT) {340  async function testPreventsFromSettingAccessRightsNotAdminOrOwner(collection: UniqueNFTCollection | UniqueRFTCollection) {
342    await expect(collection.setTokenPropertyPermissions(bob, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]))341    await expect(collection.setTokenPropertyPermissions(bob, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]))
343      .to.be.rejectedWith(/common\.NoPermission/);342      .to.be.rejectedWith(/common\.NoPermission/);
344343
354    await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.rft.mintCollection(alice));353    await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.rft.mintCollection(alice));
355  });354  });
356355
357  async function testPreventFromAddingTooManyPossibleProperties(collection: ICollectionNFT | ICollectionRFT) {  356  async function testPreventFromAddingTooManyPossibleProperties(collection: UniqueNFTCollection | UniqueRFTCollection) {  
358    const constitution = [];357    const constitution = [];
359    for (let i = 0; i < 65; i++) {358    for (let i = 0; i < 65; i++) {
360      constitution.push({359      constitution.push({
378    await testPreventFromAddingTooManyPossibleProperties(await helper.rft.mintCollection(alice));377    await testPreventFromAddingTooManyPossibleProperties(await helper.rft.mintCollection(alice));
379  });378  });
380379
381  async function testPreventAccessRightsModifiedIfConstant(collection: ICollectionNFT | ICollectionRFT) {380  async function testPreventAccessRightsModifiedIfConstant(collection: UniqueNFTCollection | UniqueRFTCollection) {
382    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))381    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))
383      .to.be.fulfilled;382      .to.be.fulfilled;
384383
399    await testPreventAccessRightsModifiedIfConstant(await helper.rft.mintCollection(alice));398    await testPreventAccessRightsModifiedIfConstant(await helper.rft.mintCollection(alice));
400  });399  });
401400
402  async function testPreventsAddingPropertiesWithInvalidNames(collection: ICollectionNFT | ICollectionRFT) {401  async function testPreventsAddingPropertiesWithInvalidNames(collection: UniqueNFTCollection | UniqueRFTCollection) {
403    const invalidProperties = [402    const invalidProperties = [
404      [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],403      [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],
405      [{key: 'G#4', permission: {tokenOwner: true}}],404      [{key: 'G#4', permission: {tokenOwner: true}}],
469    ];468    ];
470  });469  });
471  470  
472  async function testReadsYetEmptyProperties(token: ITokenNonfungible | ITokenRefungible) {471  async function testReadsYetEmptyProperties(token: UniqueNFToken | UniqueRFToken) {
473    const properties = await token.getProperties();472    const properties = await token.getProperties();
474    expect(properties).to.be.empty;473    expect(properties).to.be.empty;
475474
489    await testReadsYetEmptyProperties(token);488    await testReadsYetEmptyProperties(token);
490  });489  });
491490
492  async function testAssignPropertiesAccordingToPermissions(token: ITokenNonfungible | ITokenRefungible, pieces: bigint) {491  async function testAssignPropertiesAccordingToPermissions(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
493    await token.collection.addAdmin(alice, {Substrate: bob.address});492    await token.collection.addAdmin(alice, {Substrate: bob.address});
494    await token.transfer(alice, {Substrate: charlie.address}, pieces);493    await token.transfer(alice, {Substrate: charlie.address}, pieces);
495494
535    await testAssignPropertiesAccordingToPermissions(token, 100n);534    await testAssignPropertiesAccordingToPermissions(token, 100n);
536  });535  });
537536
538  async function testChangesPropertiesAccordingPermission(token: ITokenNonfungible | ITokenRefungible, pieces: bigint) {537  async function testChangesPropertiesAccordingPermission(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
539    await token.collection.addAdmin(alice, {Substrate: bob.address});538    await token.collection.addAdmin(alice, {Substrate: bob.address});
540    await token.transfer(alice, {Substrate: charlie.address}, pieces);539    await token.transfer(alice, {Substrate: charlie.address}, pieces);
541540
588    await testChangesPropertiesAccordingPermission(token, 100n);587    await testChangesPropertiesAccordingPermission(token, 100n);
589  });588  });
590589
591  async function testDeletePropertiesAccordingPermission(token: ITokenNonfungible | ITokenRefungible, pieces: bigint) {590  async function testDeletePropertiesAccordingPermission(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
592    await token.collection.addAdmin(alice, {Substrate: bob.address});591    await token.collection.addAdmin(alice, {Substrate: bob.address});
593    await token.transfer(alice, {Substrate: charlie.address}, pieces);592    await token.transfer(alice, {Substrate: charlie.address}, pieces);
594593
799    return (await (mode == 'NFT' ? api.query.nonfungible : api.query.refungible).tokenProperties(collectionId, tokenId)).toJSON().consumedSpace;798    return (await (mode == 'NFT' ? api.query.nonfungible : api.query.refungible).tokenProperties(collectionId, tokenId)).toJSON().consumedSpace;
800  }799  }
801800
802  async function prepare(token: ITokenNonfungible | ITokenRefungible, pieces: bigint): Promise<number> {801  async function prepare(token: UniqueNFToken | UniqueRFToken, pieces: bigint): Promise<number> {
803    await token.collection.addAdmin(alice, {Substrate: bob.address});802    await token.collection.addAdmin(alice, {Substrate: bob.address});
804    await token.transfer(alice, {Substrate: charlie.address}, pieces);803    await token.transfer(alice, {Substrate: charlie.address}, pieces);
805804
823    return originalSpace;822    return originalSpace;
824  }823  }
825824
826  async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token: ITokenNonfungible | ITokenRefungible, pieces: bigint) {825  async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
827    const originalSpace = await prepare(token, pieces);826    const originalSpace = await prepare(token, pieces);
828827
829    let i = 0;828    let i = 0;
858    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, 100n);857    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, 100n);
859  });858  });
860859
861  async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(token: ITokenNonfungible | ITokenRefungible, pieces: bigint) {860  async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
862    const originalSpace = await prepare(token, pieces);861    const originalSpace = await prepare(token, pieces);
863862
864    let i = 0;863    let i = 0;
893    await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, 100n);892    await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, 100n);
894  });893  });
895894
896  async function testForbidsAddingPropertiesIfPropertyNotDeclared(token: ITokenNonfungible | ITokenRefungible, pieces: bigint) {895  async function testForbidsAddingPropertiesIfPropertyNotDeclared(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
897    const originalSpace = await prepare(token, pieces);896    const originalSpace = await prepare(token, pieces);
898897
899    await expect(898    await expect(
929    await testForbidsAddingPropertiesIfPropertyNotDeclared(token, 100n);928    await testForbidsAddingPropertiesIfPropertyNotDeclared(token, 100n);
930  });929  });
931930
932  async function testForbidsAddingTooManyProperties(token: ITokenNonfungible | ITokenRefungible, pieces: bigint) {931  async function testForbidsAddingTooManyProperties(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
933    const originalSpace = await prepare(token, pieces);932    const originalSpace = await prepare(token, pieces);
934933
935    await expect(934    await expect(
984    });983    });
985  });984  });
986985
987  async function prepare(helper: UniqueHelper): Promise<ITokenRefungible> {986  async function prepare(helper: UniqueHelper): Promise<UniqueRFToken> {
988    const collection = await helper.rft.mintCollection(alice);987    const collection = await helper.rft.mintCollection(alice);
989    const token = await collection.mintToken(alice, 100n);988    const token = await collection.mintToken(alice, 100n);
990    989
modifiedtests/src/util/playgrounds/index.tsdiffbeforeafterboth
--- a/tests/src/util/playgrounds/index.ts
+++ b/tests/src/util/playgrounds/index.ts
@@ -12,13 +12,6 @@
 chai.use(chaiAsPromised);
 export const expect = chai.expect;
 
-export const U128_MAX = (1n << 128n) - 1n;
-
-const MICROUNIQUE = 1_000_000_000_000n;
-const MILLIUNIQUE = 1_000n * MICROUNIQUE;
-const CENTIUNIQUE = 10n * MILLIUNIQUE;
-export const UNIQUE = 100n * CENTIUNIQUE;
-
 export const usingPlaygrounds = async (code: (helper: DevUniqueHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>, url: string = config.substrateUrl) => {
   const silentConsole = new SilentConsole();
   silentConsole.enable();
modifiedtests/src/util/playgrounds/types.tsdiffbeforeafterboth
--- a/tests/src/util/playgrounds/types.ts
+++ b/tests/src/util/playgrounds/types.ts
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {IKeyringPair} from '@polkadot/types/types';
-import {UniqueHelper} from './unique';
 
 export interface IEvent {
   section: string;
@@ -107,7 +106,7 @@
   }
 }
 
-export interface ITokenAddress {
+export interface IToken {
   collectionId: number;
   tokenId: number;
 }
@@ -168,169 +167,3 @@
 export type TApiAllowedListeners = 'connected' | 'disconnected' | 'error' | 'ready' | 'decorated';
 export type TUniqueNetworks = 'opal' | 'quartz' | 'unique';
 export type TSigner = IKeyringPair; // | 'string'
-
-export interface ICollectionBase {
-  helper: UniqueHelper;
-  collectionId: number;
-  getData: () => Promise<{
-    id: number;
-    name: string;
-    description: string;
-    tokensCount: number;
-    admins: ICrossAccountId[];
-    normalizedOwner: TSubstrateAccount;
-    raw: any
-  } | null>;
-  getLastTokenId: () => Promise<number>;
-  isTokenExists: (tokenId: number) => Promise<boolean>;
-  getAdmins: () => Promise<ICrossAccountId[]>;
-  getAllowList: () => Promise<ICrossAccountId[]>;
-  getEffectiveLimits: () => Promise<ICollectionLimits>;
-  getProperties: (propertyKeys?: string[]) => Promise<IProperty[]>;
-  getTokenNextSponsored: (tokenId: number, addressObj: ICrossAccountId) => Promise<number | null>;
-  setSponsor: (signer: TSigner, sponsorAddress: TSubstrateAccount) => Promise<boolean>;
-  confirmSponsorship: (signer: TSigner) => Promise<boolean>;
-  removeSponsor: (signer: TSigner) => Promise<boolean>;
-  setLimits: (signer: TSigner, limits: ICollectionLimits) => Promise<boolean>;
-  changeOwner: (signer: TSigner, ownerAddress: TSubstrateAccount) => Promise<boolean>;
-  addAdmin: (signer: TSigner, adminAddressObj: ICrossAccountId) => Promise<boolean>;
-  addToAllowList: (signer: TSigner, addressObj: ICrossAccountId) => Promise<boolean>;
-  removeFromAllowList: (signer: TSigner, addressObj: ICrossAccountId) => Promise<boolean>;
-  removeAdmin: (signer: TSigner, adminAddressObj: ICrossAccountId) => Promise<boolean>;
-  setProperties: (signer: TSigner, properties: IProperty[]) => Promise<boolean>;
-  deleteProperties: (signer: TSigner, propertyKeys: string[]) => Promise<boolean>;
-  setPermissions: (signer: TSigner, permissions: ICollectionPermissions) => Promise<boolean>;
-  enableNesting: (signer: TSigner, permissions: INestingPermissions) => Promise<boolean>;
-  disableNesting: (signer: TSigner) => Promise<boolean>;
-  burn: (signer: TSigner) => Promise<boolean>;
-}
-
-export interface ICollectionNFT extends ICollectionBase {
-  getTokenObject: (tokenId: number) => ITokenNonfungible; // todo:playgrounds
-  getTokensByAddress: (addressObj: ICrossAccountId) => Promise<number[]>;
-  getToken: (tokenId: number, blockHashAt?: string) => Promise<{
-    properties: IProperty[];
-    owner: ICrossAccountId;
-    normalizedOwner: ICrossAccountId;
-  }| null>;
-  getTokenOwner: (tokenId: number, blockHashAt?: string) => Promise<ICrossAccountId>;
-  getTokenTopmostOwner: (tokenId: number, blockHashAt?: string) => Promise<ICrossAccountId | null>;
-  getTokenChildren: (tokenId: number, blockHashAt?: string) => Promise<ITokenAddress[]>; // todo:playgrounds
-  getPropertyPermissions: (propertyKeys?: string[]) => Promise<ITokenPropertyPermission[]>;
-  getTokenProperties: (tokenId: number, propertyKeys?: string[]) => Promise<IProperty[]>;
-  transferToken: (signer: TSigner, tokenId: number, addressObj: ICrossAccountId) => Promise<boolean>;
-  transferTokenFrom: (signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) => Promise<boolean>;
-  approveToken: (signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) => Promise<boolean>;
-  isTokenApproved: (tokenId: number, toAddressObj: ICrossAccountId) => Promise<boolean>;
-  mintToken: (signer: TSigner, owner: ICrossAccountId, properties?: IProperty[]) => Promise<ITokenNonfungible>;// todo:playgrounds
-  mintMultipleTokens: (signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) => Promise<ITokenNonfungible[]>;// todo:playgrounds
-  burnToken: (signer: TSigner, tokenId: number) => Promise<{
-    success: boolean,
-    token: number | null
-  }>;
-  burnTokenFrom: (signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) => Promise<boolean>;
-  setTokenProperties: (signer: TSigner, tokenId: number, properties: IProperty[]) => Promise<boolean>;
-  deleteTokenProperties: (signer: TSigner, tokenId: number, propertyKeys: string[]) => Promise<boolean>;
-  setTokenPropertyPermissions: (signer: TSigner, permissions: ITokenPropertyPermission[]) => Promise<boolean>;
-  nestToken: (signer: TSigner, tokenId: number, toTokenObj: ITokenAddress) => Promise<boolean>;
-  unnestToken: (signer: TSigner, tokenId: number, fromTokenObj: ITokenAddress, toAddressObj: ICrossAccountId) => Promise<boolean>;
-}
-
-export interface ICollectionRFT extends ICollectionBase {
-  getTokenObject: (tokenId: number) => ITokenRefungible;
-  getToken: (tokenId: number, blockHashAt?: string) => Promise<{
-    properties: IProperty[];
-    owner: ICrossAccountId;
-    normalizedOwner: ICrossAccountId;
-  }| null>;
-  getTokensByAddress: (addressObj: ICrossAccountId) => Promise<number[]>;
-  getTop10TokenOwners: (tokenId: number) => Promise<ICrossAccountId[]>;
-  getTokenBalance: (tokenId: number, addressObj: ICrossAccountId) => Promise<bigint>;
-  getTokenTotalPieces: (tokenId: number) => Promise<bigint>;
-  getTokenApprovedPieces: (tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) => Promise<bigint>;
-  getPropertyPermissions: (propertyKeys?: string[] | null) => Promise<ITokenPropertyPermission[]>;
-  getTokenProperties: (tokenId: number, propertyKeys?: string[]) => Promise<IProperty[]>;
-  transferToken: (signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  transferTokenFrom: (signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  approveToken: (signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  repartitionToken: (signer: TSigner, tokenId: number, amount: bigint) => Promise<boolean>;
-  mintToken: (signer: TSigner, pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]) => Promise<ITokenRefungible>;
-  mintMultipleTokens: (signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) => Promise<ITokenRefungible[]>; // todo:playgrounds
-  burnToken: (signer: TSigner, tokenId: number, amount: bigint) => Promise<{
-    success: boolean,
-    token: number | null
-  }>;
-  burnTokenFrom: (signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId,  amount: bigint) => Promise<boolean>;
-  setTokenProperties: (signer: TSigner, tokenId: number, properties: IProperty[]) => Promise<boolean>;
-  deleteTokenProperties: (signer: TSigner, tokenId: number, propertyKeys: string[]) => Promise<boolean>;
-  setTokenPropertyPermissions: (signer: TSigner, permissions: ITokenPropertyPermission[]) => Promise<boolean>;
-}
-
-export interface ICollectionFT extends ICollectionBase {
-  getBalance: (addressObj: ICrossAccountId) => Promise<bigint>;
-  getTotalPieces: () => Promise<bigint>;
-  getApprovedTokens: (fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) => Promise<bigint>;
-  getTop10Owners: () => Promise<ICrossAccountId[]>;
-  mint: (signer: TSigner, amount: bigint, owner: ICrossAccountId) => Promise<boolean>;
-  mintWithOneOwner: (signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId) => Promise<boolean>;
-  transfer: (signer: TSigner, toAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  transferFrom: (signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  burnTokens: (signer: TSigner, amount: bigint) => Promise<boolean>;
-  burnTokensFrom: (signer: TSigner, fromAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  approveTokens: (signer: TSigner, toAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-}
-
-export interface ITokenBase extends ITokenAddress {
-  collection: ICollectionNFT | ICollectionRFT;
-  getNextSponsored: (addressObj: ICrossAccountId) => Promise<number|null>;
-  getProperties: (propertyKeys?: string[]) => Promise<IProperty[]>;
-  setProperties: (signer: TSigner, properties: IProperty[]) => Promise<boolean>;
-  deleteProperties: (signer: TSigner, propertyKeys: string[]) => Promise<boolean>;
-  nestingAccount: () => ICrossAccountId;
-  nestingAccountInLowerCase: () => ICrossAccountId;
-}
-
-export interface ITokenNonfungible extends ITokenBase {
-  collection: ICollectionNFT;
-  getData: (blockHashAt?: string) => Promise<{
-    properties: IProperty[];
-    owner: ICrossAccountId;
-    normalizedOwner: ICrossAccountId;
-  }| null>;
-  getOwner: (blockHashAt?: string) => Promise<ICrossAccountId>;
-  getTopmostOwner: (blockHashAt?: string) => Promise<ICrossAccountId | null>;
-  getChildren: (blockHashAt?: string) => Promise<ITokenAddress[]>; // todo:playgrounds
-  nest: (signer: TSigner, toTokenObj: ITokenAddress) => Promise<boolean>;
-  unnest: (signer: TSigner, fromTokenObj: ITokenAddress, toAddressObj: ICrossAccountId) => Promise<boolean>;
-  transfer: (signer: TSigner, addressObj: ICrossAccountId) => Promise<boolean>;
-  transferFrom: (signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) => Promise<boolean>;
-  approve: (signer: TSigner, toAddressObj: ICrossAccountId) => Promise<boolean>;
-  isApproved: (toAddressObj: ICrossAccountId) => Promise<boolean>;
-  burn: (signer: TSigner) => Promise<{
-    success: boolean,
-    token: number | null
-  }>;
-  burnFrom: (signer: TSigner, fromAddressObj: ICrossAccountId) => Promise<boolean>;
-}
-
-export interface ITokenRefungible extends ITokenBase {
-  collection: ICollectionRFT;
-  getData: (blockHashAt?: string) => Promise<{
-    properties: IProperty[];
-    owner: ICrossAccountId;
-    normalizedOwner: ICrossAccountId;
-  }| null>;
-  getTop10Owners: () => Promise<ICrossAccountId[]>;
-  getBalance: (addressObj: ICrossAccountId) => Promise<bigint>;
-  getTotalPieces: () => Promise<bigint>;
-  getApprovedPieces: (fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) => Promise<bigint>;
-  transfer: (signer: TSigner, addressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  transferFrom: (signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  approve: (signer: TSigner, toAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-  repartition: (signer: TSigner, amount: bigint) => Promise<boolean>;
-  burn: (signer: TSigner, amount: bigint) => Promise<{
-    success: boolean,
-    token: number | null
-  }>;
-  burnFrom: (signer: TSigner, fromAddressObj: ICrossAccountId, amount: bigint) => Promise<boolean>;
-}
modifiedtests/src/util/playgrounds/unique.tsdiffbeforeafterboth
--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -9,7 +9,7 @@
 import {ApiInterfaceEvents, SignerOptions} from '@polkadot/api/types';
 import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm} from '@polkadot/util-crypto';
 import {IKeyringPair} from '@polkadot/types/types';
-import {IApiListeners, IBlock, IEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, IStakingInfo, ISubstrateBalance, ITokenAddress, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, TUniqueNetworks, ICollectionBase, ICollectionNFT, ICollectionRFT, ITokenBase, ITokenNonfungible, ITokenRefungible, ICollectionFT} from './types';
+import {IApiListeners, IBlock, IEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, IStakingInfo, ISubstrateBalance, IToken, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, TUniqueNetworks} from './types';
 
 export const crossAccountIdFromLower = (lowerAddress: ICrossAccountIdLower): ICrossAccountId => {
   const address = {} as ICrossAccountId;
@@ -55,15 +55,15 @@
     RPC: 'rpc',
   };
 
-  static getTokenAccount(token: ITokenAddress): ICrossAccountId {
+  static getTokenAccount(token: IToken): ICrossAccountId {
     return {Ethereum: this.getTokenAddress(token)};
   }
 
-  static getTokenAccountInLowerCase(token: ITokenAddress): ICrossAccountId {
+  static getTokenAccountInLowerCase(token: IToken): ICrossAccountId {
     return {Ethereum: this.getTokenAddress(token).toLowerCase()};
   }
 
-  static getTokenAddress(token: ITokenAddress): string {
+  static getTokenAddress(token: IToken): string {
     return nesting.tokenIdToAddress(token.collectionId, token.tokenId);
   }
 
@@ -1218,7 +1218,7 @@
    * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")
    * @returns object of the created collection
    */
-  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueCollectionBase> {
+  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {
     collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object
     collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};
     for (const key of ['name', 'description', 'tokenPrefix']) {
@@ -1260,8 +1260,8 @@
    * @example getTokenObject(10, 5);
    * @returns instance of UniqueNFTToken
    */
-  getTokenObject(collectionId: number, tokenId: number): UniqueNFTToken {
-    return new UniqueNFTToken(tokenId, this.getCollectionObject(collectionId));
+  getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {
+    return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));
   }
 
   /**
@@ -1352,7 +1352,7 @@
    * @example getTokenChildren(10, 5);
    * @returns tokens whose depth of nesting is <= 5
    */
-  async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<ITokenAddress[]> {
+  async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {
     let children;
     if(typeof blockHashAt === 'undefined') {
       children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);
@@ -1373,7 +1373,7 @@
    * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});
    * @returns ```true``` if extrinsic success, otherwise ```false```
    */
-  async nestToken(signer: TSigner, tokenObj: ITokenAddress, rootTokenObj: ITokenAddress): Promise<boolean> {
+  async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {
     const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);
     const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);
     if(!result) {
@@ -1391,7 +1391,7 @@
    * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});
    * @returns ```true``` if extrinsic success, otherwise ```false```
    */
-  async unnestToken(signer: TSigner, tokenObj: ITokenAddress, rootTokenObj: ITokenAddress, toAddressObj: ICrossAccountId): Promise<boolean> {
+  async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {
     const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);
     const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);
     if(!result) {
@@ -1422,7 +1422,7 @@
    * @param data token data
    * @returns created token object
    */
-  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFTToken> {
+  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {
     const creationResult = await this.helper.executeExtrinsic(
       signer,
       'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {
@@ -1453,14 +1453,14 @@
    * }]);
    * @returns ```true``` if extrinsic success, otherwise ```false```
    */
-  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFTToken[]> {
+  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {
     const creationResult = await this.helper.executeExtrinsic(
       signer,
       'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],
       true,
     );
     const collection = this.getCollectionObject(collectionId);
-    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: ITokenAddress) => collection.getTokenObject(x.tokenId));
+    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));
   }
 
   /**
@@ -1481,7 +1481,7 @@
    * }]);
    * @returns array of newly created tokens
    */
-  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFTToken[]> {
+  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {
     const rawTokens = [];
     for (const token of tokens) {
       const raw = {NFT: {properties: token.properties}};
@@ -1493,7 +1493,7 @@
       true,
     );
     const collection = this.getCollectionObject(collectionId);
-    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: ITokenAddress) => collection.getTokenObject(x.tokenId));
+    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));
   }
 
   /**
@@ -1530,8 +1530,8 @@
    * @example getTokenObject(10, 5);
    * @returns instance of UniqueNFTToken
    */
-  getTokenObject(collectionId: number, tokenId: number): UniqueRFTToken {
-    return new UniqueRFTToken(tokenId, this.getCollectionObject(collectionId));
+  getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {
+    return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));
   }
 
   /**
@@ -1609,7 +1609,7 @@
    * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});
    * @returns created token object
    */
-  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFTToken> {
+  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {
     const creationResult = await this.helper.executeExtrinsic(
       signer,
       'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {
@@ -1626,7 +1626,7 @@
     return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);
   }
 
-  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFTToken[]> {
+  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {
     throw Error('Not implemented');
     const creationResult = await this.helper.executeExtrinsic(
       signer,
@@ -1634,7 +1634,7 @@
       true, // `Unable to mint RFT tokens for ${label}`,
     );
     const collection = this.getCollectionObject(collectionId);
-    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: ITokenAddress) => collection.getTokenObject(x.tokenId));
+    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));
   }
 
   /**
@@ -1646,7 +1646,7 @@
    * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);
    * @returns array of newly created RFT tokens
    */
-  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFTToken[]> {
+  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {
     const rawTokens = [];
     for (const token of tokens) {
       const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};
@@ -1658,7 +1658,7 @@
       true,
     );
     const collection = this.getCollectionObject(collectionId);
-    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: ITokenAddress) => collection.getTokenObject(x.tokenId));
+    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));
   }
 
   /**
@@ -1985,7 +1985,7 @@
 
 class BalanceGroup extends HelperGroup {
   /**
-   * Representation of the native token in the smallest unit
+   * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).
    * @example getOneTokenNominal()
    * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.
    */
@@ -2223,7 +2223,7 @@
 }
 
 
-class UniqueCollectionBase implements ICollectionBase {
+export class UniqueBaseCollection {
   helper: UniqueHelper;
   collectionId: number;
 
@@ -2326,9 +2326,9 @@
 }
 
 
-class UniqueNFTCollection extends UniqueCollectionBase implements ICollectionNFT {
+export class UniqueNFTCollection extends UniqueBaseCollection {
   getTokenObject(tokenId: number) {
-    return new UniqueNFTToken(tokenId, this);
+    return new UniqueNFToken(tokenId, this);
   }
 
   async getTokensByAddress(addressObj: ICrossAccountId) {
@@ -2403,19 +2403,19 @@
     return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);
   }
 
-  async nestToken(signer: TSigner, tokenId: number, toTokenObj: ITokenAddress) {
+  async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {
     return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);
   }
 
-  async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: ITokenAddress, toAddressObj: ICrossAccountId) {
+  async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {
     return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);
   }
 }
 
 
-class UniqueRFTCollection extends UniqueCollectionBase implements ICollectionRFT {
+export class UniqueRFTCollection extends UniqueBaseCollection {
   getTokenObject(tokenId: number) {
-    return new UniqueRFTToken(tokenId, this);
+    return new UniqueRFToken(tokenId, this);
   }
 
   async getToken(tokenId: number, blockHashAt?: string) {
@@ -2496,7 +2496,7 @@
 }
 
 
-class UniqueFTCollection extends UniqueCollectionBase implements ICollectionFT {
+export class UniqueFTCollection extends UniqueBaseCollection {
   async getBalance(addressObj: ICrossAccountId) {
     return await this.helper.ft.getBalance(this.collectionId, addressObj);
   }
@@ -2543,7 +2543,7 @@
 }
 
 
-class UniqueTokenBase implements ITokenBase {
+export class UniqueBaseToken {
   collection: UniqueNFTCollection | UniqueRFTCollection;
   collectionId: number;
   tokenId: number;
@@ -2580,7 +2580,7 @@
 }
 
 
-class UniqueNFTToken extends UniqueTokenBase implements ITokenNonfungible {
+export class UniqueNFToken extends UniqueBaseToken {
   collection: UniqueNFTCollection;
 
   constructor(tokenId: number, collection: UniqueNFTCollection) {
@@ -2604,11 +2604,11 @@
     return await this.collection.getTokenChildren(this.tokenId, blockHashAt);
   }
 
-  async nest(signer: TSigner, toTokenObj: ITokenAddress) {
+  async nest(signer: TSigner, toTokenObj: IToken) {
     return await this.collection.nestToken(signer, this.tokenId, toTokenObj);
   }
 
-  async unnest(signer: TSigner, fromTokenObj: ITokenAddress, toAddressObj: ICrossAccountId) {
+  async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {
     return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);
   }
 
@@ -2637,7 +2637,7 @@
   }
 }
 
-class UniqueRFTToken extends UniqueTokenBase implements ITokenRefungible {
+export class UniqueRFToken extends UniqueBaseToken {
   collection: UniqueRFTCollection;
 
   constructor(tokenId: number, collection: UniqueRFTCollection) {