`63e242dc3f1d`

4 files changed

modifiedpallets/nonfungible/src/common.rsdiff before after both

473		None473		None
474	}474	}
475475
476	fn total_pieces(&self, _token: TokenId) -> Option<u128> {476	fn total_pieces(&self, token: TokenId) -> Option<u128> {
477		if <TokenData<T>>::contains_key((self.id, token)) {
477		Some(1)478			Some(1)
478	}479		} else {
480			None
481		}
482	}
479}483}
480484

modifiedprimitives/data-structs/src/lib.rsdiff before after both

181pub struct TokenData<CrossAccountId> {181pub struct TokenData<CrossAccountId> {
182	pub properties: Vec<Property>,182	pub properties: Vec<Property>,
183	pub owner: Option<CrossAccountId>,183	pub owner: Option<CrossAccountId>,
184	pub pieces: Option<u128>,
184}185}
185186
186pub struct OverflowError;187pub struct OverflowError;

modifiedruntime/common/src/runtime_apis.rsdiff before after both

89                ) -> Result<TokenData<CrossAccountId>, DispatchError> {89                ) -> Result<TokenData<CrossAccountId>, DispatchError> {
90                    let token_data = TokenData {90                    let token_data = TokenData {
91                        properties: Self::token_properties(collection, token_id, keys)?,91                        properties: Self::token_properties(collection, token_id, keys)?,
92                        owner: Self::token_owner(collection, token_id)?92                        owner: Self::token_owner(collection, token_id)?,
93                        pieces: Self::total_pieces(collection, token_id)?
93                    };94                    };
9495
95                    Ok(token_data)96                    Ok(token_data)

modifiedtests/src/createItem.test.tsdiff before after both

98    await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'key1', value: 'val1'}]);98    await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'key1', value: 'val1'}]);
99  });99  });
100100
101  it.only('Check total pieces of Fungible token', async () => {101  it('Check total pieces of Fungible token', async () => {
102    await usingApi(async api => {102    await usingApi(async api => {
103      const createMode = 'Fungible';103      const createMode = 'Fungible';
104      const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});104      const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
105      const amountPieces = 10n;
105      const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);106      const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
106      {107      {
107        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);108        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
108        expect(totalPieces.isSome).to.be.true;109        expect(totalPieces.isSome).to.be.true;
109        expect(totalPieces.unwrap().toBigInt()).to.be.eq(10n);110        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
110      }111      }
111112
112      await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);113      await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);
113      {114      {
114        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);115        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
115        expect(totalPieces.isSome).to.be.true;116        expect(totalPieces.isSome).to.be.true;
116        expect(totalPieces.unwrap().toBigInt()).to.be.eq(10n);117        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
117      }118      }
119
120      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
121      expect(totalPieces.isSome).to.be.true;
122      expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
118    });123    });
119  });124  });
120125
121  it.only('Check total pieces of NFT token', async () => {126  it('Check total pieces of NFT token', async () => {
122    await usingApi(async api => {127    await usingApi(async api => {
123      const createMode = 'NFT';128      const createMode = 'NFT';
124      const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});129      const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
130      const amountPieces = 1n;
125      const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);131      const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
126      {132      {
127        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);133        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
128        expect(totalPieces.isSome).to.be.true;134        expect(totalPieces.isSome).to.be.true;
129        expect(totalPieces.unwrap().toBigInt()).to.be.eq(1n);135        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
130      }136      }
131137
132      await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);138      await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);
133      {139      {
134        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);140        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
135        expect(totalPieces.isSome).to.be.true;141        expect(totalPieces.isSome).to.be.true;
136        expect(totalPieces.unwrap().toBigInt()).to.be.eq(1n);142        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
137      }143      }
144
145      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
146      expect(totalPieces.isSome).to.be.true;
147      expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
138    });148    });
139  });149  });
140150
141  it.only('Check total pieces of ReFungible token', async () => {151  it('Check total pieces of ReFungible token', async () => {
142    await usingApi(async api => {152    await usingApi(async api => {
143      const createMode = 'ReFungible';153      const createMode = 'ReFungible';
144      const createCollectionResult = await createCollection(api, alice, {mode: {type: createMode}});154      const createCollectionResult = await createCollection(api, alice, {mode: {type: createMode}});
158        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);168        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
159      }169      }
170
171      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
172      expect(totalPieces.isSome).to.be.true;
173      expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
160    });174    });
161  });175  });
162});176});
234    });248    });
235  });249  });
250
251  it('Check total pieces for invalid Fungible token', async () => {
252    await usingApi(async api => {
253      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'Fungible', decimalPoints: 0}});
254      const collectionId  = createCollectionResult.collectionId;
255      const invalidTokenId = 1000_000;
256      
257      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
258      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.isNone).to.be.true;
259    });
260  });
261
262  it('Check total pieces for invalid NFT token', async () => {
263    await usingApi(async api => {
264      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'NFT'}});
265      const collectionId  = createCollectionResult.collectionId;
266      const invalidTokenId = 1000_000;
267      
268      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
269      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.isNone).to.be.true;
270    });
271  });
272
273  it('Check total pieces for invalid Refungible token', async () => {
274    await usingApi(async api => {
275      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'ReFungible'}});
276      const collectionId  = createCollectionResult.collectionId;
277      const invalidTokenId = 1000_000;
278      
279      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
280      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.isNone).to.be.true;
281    });
282  });
236});283});
237284