difftreelog
Scheduler refactored and fixed
in: master
8 files changed
pallets/nft-charge-transaction/src/lib.rsdiffbeforeafterboth--- a/pallets/nft-charge-transaction/src/lib.rs
+++ b/pallets/nft-charge-transaction/src/lib.rs
@@ -135,6 +135,13 @@
.map(|i| (fee, i));
}
+ // check errors
+ let error = <pallet_nft_transaction_payment::Module<T>>::check_error(who, call);
+ match error {
+ Err(error) => return Err(error),
+ Ok(error) => {}
+ };
+
// Determine who is paying transaction fee based on ecnomic model
// Parse call to extract collection ID and access collection sponsor
let sponsor = <pallet_nft_transaction_payment::Module<T>>::withdraw_type(who, call);
pallets/nft-transaction-payment/README.mddiffbeforeafterboth--- /dev/null
+++ b/pallets/nft-transaction-payment/README.md
@@ -0,0 +1,13 @@
+# Nft Transaction Payment
+
+## Overview
+
+A module containing the sponsoring logic for paying for sponsored collections
+
+**NOTE:** The scheduled calls will be dispatched with the default filter
+for the origin: namely `frame_system::Config::BaseCallFilter` for all origin
+except root which will get no filter. And not the filter contained in origin
+use to call `fn schedule`.
+
+If a call is scheduled using proxy or whatever mecanism which adds filter,
+then those filter will not be used when dispatching the schedule call.
pallets/nft-transaction-payment/src/lib.rsdiffbeforeafterboth--- a/pallets/nft-transaction-payment/src/lib.rs
+++ b/pallets/nft-transaction-payment/src/lib.rs
@@ -31,6 +31,9 @@
traits::{
Hash, Dispatchable,
},
+ transaction_validity::{
+ InvalidTransaction, TransactionValidityError,
+ },
};
use pallet_contracts::chain_extension::UncheckedFrom;
use sp_std::prelude::*;
@@ -85,6 +88,36 @@
impl<T: Config> Module<T>
{
+ pub fn check_error(
+ who: &T::AccountId,
+ call: &T::Call
+ ) -> Result<bool, TransactionValidityError> where
+ T::Call: Dispatchable<Info=DispatchInfo>,
+ T::Call: IsSubType<pallet_nft::Call<T>>,
+ T::Call: IsSubType<pallet_contracts::Call<T>>,
+ T::AccountId: AsRef<[u8]>,
+ T::AccountId: UncheckedFrom<T::Hash>
+ {
+
+ match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {
+ Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {
+
+ let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());
+
+ let owned_contract = pallet_nft::ContractOwner::<T>::get(called_contract.clone()).as_ref() == Some(who);
+ let white_list_enabled = pallet_nft::ContractWhiteListEnabled::<T>::contains_key(called_contract.clone());
+
+ if !owned_contract && white_list_enabled {
+ if !pallet_nft::ContractWhiteList::<T>::contains_key(called_contract.clone(), who) {
+ return Err(InvalidTransaction::Call.into());
+ }
+ }
+ Ok(true)
+ },
+ _ => { Ok(true) },
+ }
+ }
+
pub fn withdraw_type(
who: &T::AccountId,
call: &T::Call
@@ -366,160 +399,4 @@
None
}
-}
-
-// type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;
-
-// /// Require the transactor pay for themselves and maybe include a tip to gain additional priority
-// /// in the queue.
-// #[derive(Encode, Decode, Clone, Eq, PartialEq)]
-// pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);
-
-// impl<T: Config + Send + Sync> sp_std::fmt::Debug
-// for ChargeTransactionPayment<T>
-// {
-// #[cfg(feature = "std")]
-// fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
-// write!(f, "ChargeTransactionPayment<{:?}>", self.0)
-// }
-// #[cfg(not(feature = "std"))]
-// fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
-// Ok(())
-// }
-// }
-
-// impl<T: Config> ChargeTransactionPayment<T>
-// where
-// T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<pallet_nft::Call<T>> + IsSubType<pallet_contracts::Call<T>>,
-// BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,
-// T::AccountId: AsRef<[u8]>,
-// T::AccountId: UncheckedFrom<T::Hash>,
-// {
-// fn traditional_fee(
-// len: usize,
-// info: &DispatchInfoOf<T::Call>,
-// tip: BalanceOf<T>,
-// ) -> BalanceOf<T>
-// where
-// T::Call: Dispatchable<Info = DispatchInfo>,
-// {
-// <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)
-// }
-
-// fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {
-// let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);
-// let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);
-// let len_saturation = max_block_length as u64 / (len as u64).max(1);
-// let coefficient: BalanceOf<T> = weight_saturation
-// .min(len_saturation)
-// .saturated_into::<BalanceOf<T>>();
-// final_fee
-// .saturating_mul(coefficient)
-// .saturated_into::<TransactionPriority>()
-// }
-
-// fn withdraw_fee(
-// &self,
-// who: &T::AccountId,
-// call: &T::Call,
-// info: &DispatchInfoOf<T::Call>,
-// len: usize,
-// ) -> Result<
-// (
-// BalanceOf<T>,
-// <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,
-// ),
-// TransactionValidityError,
-// > {
-// let tip = self.0;
-
-// let fee = Self::traditional_fee(len, info, tip);
-
-// // Only mess with balances if fee is not zero.
-// if fee.is_zero() {
-// return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)
-// .map(|i| (fee, i));
-// }
-
-// // Determine who is paying transaction fee based on ecnomic model
-// // Parse call to extract collection ID and access collection sponsor
-
-// let sponsor = pallet_nft_transaction_payment::<T>::withdraw_type(who, call);
-// //let sponsor = Self::Module::<T>::withdraw_type(who, call);;
-// // <pallet_nft_transaction_payment::Module<T>>::withdraw_type(who, call);
-
-// let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());
-
-// <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)
-// .map(|i| (fee, i))
-// }
-// }
-
-
-// impl<T: Config + Send + Sync> SignedExtension
-// for ChargeTransactionPayment<T>
-// where
-// BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,
-// T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<pallet_nft::Call<T>> + IsSubType<pallet_contracts::Call<T>>,
-// T::AccountId: AsRef<[u8]>,
-// T::AccountId: UncheckedFrom<T::Hash>,
-// {
-// const IDENTIFIER: &'static str = "ChargeTransactionPayment";
-// type AccountId = T::AccountId;
-// type Call = T::Call;
-// type AdditionalSigned = ();
-// type Pre = (
-// // tip
-// BalanceOf<T>,
-// // who pays fee
-// Self::AccountId,
-// // imbalance resulting from withdrawing the fee
-// <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,
-// );
-// fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
-// Ok(())
-// }
-
-// fn validate(
-// &self,
-// who: &Self::AccountId,
-// call: &Self::Call,
-// info: &DispatchInfoOf<Self::Call>,
-// len: usize,
-// ) -> TransactionValidity {
-// let (fee, _) = self.withdraw_fee(who, call, info, len)?;
-// Ok(ValidTransaction {
-// priority: Self::get_priority(len, info, fee),
-// ..Default::default()
-// })
-// }
-
-// fn pre_dispatch(
-// self,
-// who: &Self::AccountId,
-// call: &Self::Call,
-// info: &DispatchInfoOf<Self::Call>,
-// len: usize,
-// ) -> Result<Self::Pre, TransactionValidityError> {
-// let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;
-// Ok((self.0, who.clone(), imbalance))
-// }
-
-// fn post_dispatch(
-// pre: Self::Pre,
-// info: &DispatchInfoOf<Self::Call>,
-// post_info: &PostDispatchInfoOf<Self::Call>,
-// len: usize,
-// _result: &DispatchResult,
-// ) -> Result<(), TransactionValidityError> {
-// let (tip, who, imbalance) = pre;
-// let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(
-// len as u32,
-// info,
-// post_info,
-// tip,
-// );
-// <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;
-// Ok(())
-// }
-// }
\ No newline at end of file
+}
\ No newline at end of file
pallets/nft/src/lib.rsdiffbeforeafterboth--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -32,10 +32,11 @@
use frame_system::{self as system, ensure_signed, ensure_root};
use sp_runtime::sp_std::prelude::Vec;
+use core::ops::{Deref, DerefMut};
use nft_data_structs::{
MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,
AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits,
- CollectionId, CollectionMode, CollectionHandle, TokenId,
+ CollectionId, CollectionMode, TokenId,
SchemaVersion, SponsorshipState, Ownership,
NftItemType, FungibleItemType, ReFungibleItemType
};
@@ -164,7 +165,25 @@
}
}
-// + pallet_transaction_payment::Config + pallet_nft_transaction_payment::Config + pallet_contracts::Config
+pub struct CollectionHandle<T: frame_system::Config> {
+ pub id: CollectionId,
+ pub collection: Collection<T>,
+}
+
+impl<T: frame_system::Config> Deref for CollectionHandle<T> {
+ type Target = Collection<T>;
+
+ fn deref(&self) -> &Self::Target {
+ &self.collection
+ }
+}
+
+impl<T: frame_system::Config> DerefMut for CollectionHandle<T> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.collection
+ }
+}
+
pub trait Config: system::Config + Sized {
pallets/scheduler/src/lib.rsdiffbeforeafterboth--- a/pallets/scheduler/src/lib.rs
+++ b/pallets/scheduler/src/lib.rs
@@ -102,7 +102,7 @@
/// Not strictly enforced, but used for weight estimation.
type MaxScheduledPerBlock: Get<u32>;
- /// TODO
+ /// Sponsoring function
type Sponsoring: SponsoringResolve<Self::AccountId, <Self as Config>::Call>;
/// Weight information for extrinsics in this pallet.
@@ -230,8 +230,7 @@
/// - Write: Agenda
/// - Will use base weight of 25 which should be good for up to 30 scheduled calls
/// # </weight>
- // #[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]
- #[weight = 0]
+ #[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]
fn schedule(origin,
when: T::BlockNumber,
maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
@@ -367,7 +366,7 @@
}
queued.sort_by_key(|(_, s)| s.priority);
let base_weight: Weight = T::DbWeight::get().reads_writes(1, 2); // Agenda + Agenda(next)
- let mut total_weight: Weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get());
+ let mut total_weight: Weight = 0;
queued.into_iter()
.enumerate()
.scan(base_weight, |cumulative_weight, (order, (index, s))| {
@@ -407,7 +406,7 @@
).into();
let sender = ensure_signed(origin).unwrap_or(T::AccountId::default());
let who_will_pay = T::Sponsoring::resolve(&sender, &s.call.clone()).unwrap_or(
- T::AccountId::default());
+ sender);
let sponsor = T::PalletsOrigin::from(system::RawOrigin::Signed(who_will_pay));
let r = s.call.clone().dispatch(sponsor.into());
let maybe_id = s.maybe_id.clone();
tests/src/pallet-presence.test.tsdiffbeforeafterboth--- a/tests/src/pallet-presence.test.ts
+++ b/tests/src/pallet-presence.test.ts
@@ -13,7 +13,8 @@
// Pallets that must always be present
const requiredPallets = [
- 'nft', 'inflation', 'balances', 'contracts', 'randomnesscollectiveflip', 'system', 'timestamp', 'transactionpayment', 'treasury', 'vesting'
+ 'nft', 'inflation', 'balances', 'contracts', 'randomnesscollectiveflip', 'system', 'timestamp', 'transactionpayment', 'treasury', 'vesting',
+ 'scheduler', 'nftpayment', 'charging'
];
// Pallets that depend on consensus and governance configuration
tests/src/scheduler.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/scheduler.test.ts
@@ -0,0 +1,94 @@
+//
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE', which is part of this source code package.
+//
+
+import { IKeyringPair } from '@polkadot/types/types';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import privateKey from './substrate/privateKey';
+import usingApi from './substrate/substrate-api';
+import {
+ createItemExpectSuccess,
+ createCollectionExpectSuccess,
+ destroyCollectionExpectSuccess,
+ findNotExistingCollection,
+ queryCollectionExpectSuccess,
+ setOffchainSchemaExpectFailure,
+ setOffchainSchemaExpectSuccess,
+ transferExpectSuccess,
+ scheduleTransferExpectSuccess,
+ setCollectionSponsorExpectSuccess,
+ confirmSponsorshipExpectSuccess
+} from './util/helpers';
+
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+const DATA = [1, 2, 3, 4];
+
+describe('Integration Test scheduler base transaction', () => {
+ let alice: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ alice = privateKey('//Alice');
+ });
+ });
+
+ it('User can transfer owned token with delay (scheduler)', async () => {
+ await usingApi(async (api) => {
+ const Alice = privateKey('//Alice');
+ const Bob = privateKey('//Bob');
+ // nft
+ const nftCollectionId = await createCollectionExpectSuccess();
+ const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+ await setCollectionSponsorExpectSuccess(nftCollectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(nftCollectionId);
+
+ await scheduleTransferExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
+ });
+ });
+
+
+});
+
+// describe('Negative Integration Test setOffchainSchema', () => {
+// let alice: IKeyringPair;
+// let bob: IKeyringPair;
+
+// let validCollectionId: number;
+
+// before(async () => {
+// await usingApi(async () => {
+// alice = privateKey('//Alice');
+// bob = privateKey('//Bob');
+
+// validCollectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+// });
+// });
+
+// it('fails on not existing collection id', async () => {
+// const nonExistingCollectionId = await usingApi(findNotExistingCollection);
+
+// await setOffchainSchemaExpectFailure(alice, nonExistingCollectionId, DATA);
+// });
+
+// it('fails on destroyed collection id', async () => {
+// const destroyedCollectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+// await destroyCollectionExpectSuccess(destroyedCollectionId);
+
+// await setOffchainSchemaExpectFailure(alice, destroyedCollectionId, DATA);
+// });
+
+// it('fails on too long data', async () => {
+// const tooLongData = new Array(4097).fill(0xff);
+
+// await setOffchainSchemaExpectFailure(alice, validCollectionId, tooLongData);
+// });
+
+// it('fails on execution by non-owner', async () => {
+// await setOffchainSchemaExpectFailure(bob, validCollectionId, DATA);
+// });
+// });
tests/src/util/helpers.tsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56import { ApiPromise, Keyring } from '@polkadot/api';7import { Enum, Struct } from '@polkadot/types/codec';8import type { AccountId, EventRecord } from '@polkadot/types/interfaces';9import { u128 } from '@polkadot/types/primitive';10import { IKeyringPair } from '@polkadot/types/types';11import { BigNumber } from 'bignumber.js';12import BN from 'bn.js';13import chai from 'chai';14import chaiAsPromised from 'chai-as-promised';15import { alicesPublicKey, nullPublicKey } from '../accounts';16import privateKey from '../substrate/privateKey';17import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';18import { ICollectionInterface } from '../types';19import { hexToStr, strToUTF16, utf16ToStr } from './util';2021chai.use(chaiAsPromised);22const expect = chai.expect;2324export const U128_MAX = (1n << 128n) - 1n;2526type GenericResult = {27 success: boolean,28};2930interface CreateCollectionResult {31 success: boolean;32 collectionId: number;33}3435interface CreateItemResult {36 success: boolean;37 collectionId: number;38 itemId: number;39 recipient: string;40}4142interface TransferResult {43 success: boolean;44 collectionId: number;45 itemId: number;46 sender: string;47 recipient: string;48 value: bigint;49}5051interface IReFungibleOwner {52 Fraction: BN;53 Owner: number[];54}5556interface ITokenDataType {57 Owner: number[];58 ConstData: number[];59 VariableData: number[];60}6162interface IFungibleTokenDataType {63 Value: BN;64}6566interface IGetMessage {67 checkMsgNftMethod: string;68 checkMsgTrsMethod: string;69 checkMsgSysMethod: string;70}7172export interface IReFungibleTokenDataType {73 Owner: IReFungibleOwner[];74 ConstData: number[];75 VariableData: number[];76}7778export function nftEventMessage(events: EventRecord[]): IGetMessage {79 let checkMsgNftMethod: string = '';80 let checkMsgTrsMethod: string = '';81 let checkMsgSysMethod: string = '';82 events.forEach(({ event: { method, section } }) => {83 if (section === 'nft') {84 checkMsgNftMethod = method;85 } else if (section === 'treasury') {86 checkMsgTrsMethod = method;87 } else if (section === 'system') {88 checkMsgSysMethod = method;89 } else { return null; }90 });91 const result: IGetMessage = {92 checkMsgNftMethod,93 checkMsgTrsMethod,94 checkMsgSysMethod,95 };96 return result;97}9899export function getGenericResult(events: EventRecord[]): GenericResult {100 const result: GenericResult = {101 success: false,102 };103 events.forEach(({ phase, event: { data, method, section } }) => {104 // console.log(` ${phase}: ${section}.${method}:: ${data}`);105 if (method === 'ExtrinsicSuccess') {106 result.success = true;107 }108 });109 return result;110}111112113114export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {115 let success = false;116 let collectionId: number = 0;117 events.forEach(({ phase, event: { data, method, section } }) => {118 // console.log(` ${phase}: ${section}.${method}:: ${data}`);119 if (method == 'ExtrinsicSuccess') {120 success = true;121 } else if ((section == 'nft') && (method == 'CollectionCreated')) {122 collectionId = parseInt(data[0].toString());123 }124 });125 const result: CreateCollectionResult = {126 success,127 collectionId,128 };129 return result;130}131132export function getCreateItemResult(events: EventRecord[]): CreateItemResult {133 let success = false;134 let collectionId: number = 0;135 let itemId: number = 0;136 let recipient: string = '';137 events.forEach(({ phase, event: { data, method, section } }) => {138 // console.log(` ${phase}: ${section}.${method}:: ${data}`);139 if (method == 'ExtrinsicSuccess') {140 success = true;141 } else if ((section == 'nft') && (method == 'ItemCreated')) {142 collectionId = parseInt(data[0].toString());143 itemId = parseInt(data[1].toString());144 recipient = data[2].toString();145 }146 });147 const result: CreateItemResult = {148 success,149 collectionId,150 itemId,151 recipient,152 };153 return result;154}155156export function getTransferResult(events: EventRecord[]): TransferResult {157 const result: TransferResult = {158 success: false,159 collectionId: 0,160 itemId: 0,161 sender: '',162 recipient: '',163 value: 0n,164 };165166 events.forEach(({event: {data, method, section}}) => {167 if (method === 'ExtrinsicSuccess') {168 result.success = true;169 } else if (section === 'nft' && method === 'Transfer') {170 result.collectionId = +data[0].toString();171 result.itemId = +data[1].toString();172 result.sender = data[2].toString();173 result.recipient = data[3].toString();174 result.value = BigInt(data[4].toString());175 }176 });177178 return result;179}180181interface Invalid {182 type: 'Invalid';183}184185interface Nft {186 type: 'NFT';187}188189interface Fungible {190 type: 'Fungible';191 decimalPoints: number;192}193194interface ReFungible {195 type: 'ReFungible';196}197198type CollectionMode = Nft | Fungible | ReFungible | Invalid;199200export type CreateCollectionParams = {201 mode: CollectionMode,202 name: string,203 description: string,204 tokenPrefix: string,205};206207const defaultCreateCollectionParams: CreateCollectionParams = {208 description: 'description',209 mode: { type: 'NFT' },210 name: 'name',211 tokenPrefix: 'prefix',212}213214export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {215 const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};216217 let collectionId: number = 0;218 await usingApi(async (api) => {219 // Get number of collections before the transaction220 const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);221222 // Run the CreateCollection transaction223 const alicePrivateKey = privateKey('//Alice');224225 let modeprm = {};226 if (mode.type === 'NFT') {227 modeprm = {nft: null};228 } else if (mode.type === 'Fungible') {229 modeprm = {fungible: mode.decimalPoints};230 } else if (mode.type === 'ReFungible') {231 modeprm = {refungible: null};232 } else if (mode.type === 'Invalid') {233 modeprm = {invalid: null};234 }235236 const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);237 const events = await submitTransactionAsync(alicePrivateKey, tx);238 const result = getCreateCollectionResult(events);239240 // Get number of collections after the transaction241 const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);242243 // Get the collection244 const collection: any = (await api.query.nft.collectionById(result.collectionId)).toJSON();245246 // What to expect247 // tslint:disable-next-line:no-unused-expression248 expect(result.success).to.be.true;249 expect(result.collectionId).to.be.equal(BcollectionCount);250 // tslint:disable-next-line:no-unused-expression251 expect(collection).to.be.not.null;252 expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');253 expect(collection.Owner).to.be.equal(alicesPublicKey);254 expect(utf16ToStr(collection.Name)).to.be.equal(name);255 expect(utf16ToStr(collection.Description)).to.be.equal(description);256 expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);257258 collectionId = result.collectionId;259 });260261 return collectionId;262}263264export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {265 const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};266267 let modeprm = {};268 if (mode.type === 'NFT') {269 modeprm = {nft: null};270 } else if (mode.type === 'Fungible') {271 modeprm = {fungible: mode.decimalPoints};272 } else if (mode.type === 'ReFungible') {273 modeprm = {refungible: null};274 } else if (mode.type === 'Invalid') {275 modeprm = {invalid: null};276 }277278 await usingApi(async (api) => {279 // Get number of collections before the transaction280 const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());281282 // Run the CreateCollection transaction283 const alicePrivateKey = privateKey('//Alice');284 const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);285 const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;286 const result = getCreateCollectionResult(events);287288 // Get number of collections after the transaction289 const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());290291 // What to expect292 // tslint:disable-next-line:no-unused-expression293 expect(result.success).to.be.false;294 expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');295 });296}297298export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {299 let bal = new BigNumber(0);300 let unused;301 do {302 const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;303 const keyring = new Keyring({ type: 'sr25519' });304 unused = keyring.addFromUri(`//${randomSeed}`);305 bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());306 } while (bal.toFixed() != '0');307 return unused;308}309310export async function getAllowance(collectionId: number, tokenId: number, owner: string, approved: string) {311 return await usingApi(async (api) => {312 const bn = await api.query.nft.allowances(collectionId, [tokenId, owner, approved]) as unknown as BN;313 return BigInt(bn.toString());314 });315}316317export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {318 return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));319}320321export async function findNotExistingCollection(api: ApiPromise): Promise<number> {322 const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;323 const newCollection: number = totalNumber + 1;324 return newCollection;325}326327function getDestroyResult(events: EventRecord[]): boolean {328 let success: boolean = false;329 events.forEach(({ phase, event: { data, method, section } }) => {330 // console.log(` ${phase}: ${section}.${method}:: ${data}`);331 if (method == 'ExtrinsicSuccess') {332 success = true;333 }334 });335 return success;336}337338export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {339 await usingApi(async (api) => {340 // Run the DestroyCollection transaction341 const alicePrivateKey = privateKey(senderSeed);342 const tx = api.tx.nft.destroyCollection(collectionId);343 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;344 });345}346347export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {348 await usingApi(async (api) => {349 // Run the DestroyCollection transaction350 const alicePrivateKey = privateKey(senderSeed);351 const tx = api.tx.nft.destroyCollection(collectionId);352 const events = await submitTransactionAsync(alicePrivateKey, tx);353 const result = getDestroyResult(events);354355 // Get the collection356 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();357358 // What to expect359 expect(result).to.be.true;360 expect(collection).to.be.null;361 });362}363364export async function queryCollectionLimits(collectionId: number) {365 return await usingApi(async (api) => {366 return ((await api.query.nft.collectionById(collectionId)).toJSON() as any).Limits;367 });368}369370export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {371 await usingApi(async (api) => {372 const oldLimits = await queryCollectionLimits(collectionId);373 const newLimits = { ...oldLimits as any, ...limits };374 const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);375 const events = await submitTransactionAsync(sender, tx);376 const result = getGenericResult(events);377378 expect(result.success).to.be.true;379 });380}381382export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {383 await usingApi(async (api) => {384 const oldLimits = await queryCollectionLimits(collectionId);385 const newLimits = { ...oldLimits as any, ...limits };386 const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);387 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;388 const result = getGenericResult(events);389390 expect(result.success).to.be.false;391 });392}393394export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {395 await usingApi(async (api) => {396397 // Run the transaction398 const alicePrivateKey = privateKey('//Alice');399 const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);400 const events = await submitTransactionAsync(alicePrivateKey, tx);401 const result = getGenericResult(events);402403 // Get the collection404 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();405406 // What to expect407 expect(result.success).to.be.true;408 expect(collection.Sponsorship).to.deep.equal({409 Unconfirmed: sponsor.toString(),410 });411 });412}413414export async function removeCollectionSponsorExpectSuccess(collectionId: number) {415 await usingApi(async (api) => {416417 // Run the transaction418 const alicePrivateKey = privateKey('//Alice');419 const tx = api.tx.nft.removeCollectionSponsor(collectionId);420 const events = await submitTransactionAsync(alicePrivateKey, tx);421 const result = getGenericResult(events);422423 // Get the collection424 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();425426 // What to expect427 expect(result.success).to.be.true;428 expect(collection.Sponsorship).to.be.deep.equal({ Disabled: null });429 });430}431432export async function removeCollectionSponsorExpectFailure(collectionId: number) {433 await usingApi(async (api) => {434435 // Run the transaction436 const alicePrivateKey = privateKey('//Alice');437 const tx = api.tx.nft.removeCollectionSponsor(collectionId);438 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;439 });440}441442export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed: string = '//Alice') {443 await usingApi(async (api) => {444445 // Run the transaction446 const alicePrivateKey = privateKey(senderSeed);447 const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);448 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;449 });450}451452export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {453 await usingApi(async (api) => {454455 // Run the transaction456 const sender = privateKey(senderSeed);457 const tx = api.tx.nft.confirmSponsorship(collectionId);458 const events = await submitTransactionAsync(sender, tx);459 const result = getGenericResult(events);460461 // Get the collection462 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();463464 // What to expect465 expect(result.success).to.be.true;466 expect(collection.Sponsorship).to.be.deep.equal({467 Confirmed: sender.address,468 });469 });470}471472473export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed: string = '//Alice') {474 await usingApi(async (api) => {475476 // Run the transaction477 const sender = privateKey(senderSeed);478 const tx = api.tx.nft.confirmSponsorship(collectionId);479 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;480 });481}482483export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {484 await usingApi(async (api) => {485 const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);486 const events = await submitTransactionAsync(sender, tx);487 const result = getGenericResult(events);488489 expect(result.success).to.be.true;490 });491}492493export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {494 await usingApi(async (api) => {495 const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);496 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;497 const result = getGenericResult(events);498499 expect(result.success).to.be.false;500 });501}502503export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {504 await usingApi(async (api) => {505 const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);506 const events = await submitTransactionAsync(sender, tx);507 const result = getGenericResult(events);508509 expect(result.success).to.be.true;510 });511}512513export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {514 await usingApi(async (api) => {515 const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);516 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;517 const result = getGenericResult(events);518519 expect(result.success).to.be.false;520 });521}522523export async function toggleContractWhitelistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enabled: boolean) {524 await usingApi(async (api) => {525 const tx = api.tx.nft.toggleContractWhiteList(contractAddress, true);526 const events = await submitTransactionAsync(sender, tx);527 const result = getGenericResult(events);528529 expect(result.success).to.be.true;530 });531}532533export async function isWhitelistedInContract(contractAddress: AccountId | string, user: string) {534 let whitelisted: boolean = false;535 await usingApi(async (api) => {536 whitelisted = (await api.query.nft.contractWhiteList(contractAddress, user)).toJSON() as boolean;537 });538 return whitelisted;539}540541export async function addToContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {542 await usingApi(async (api) => {543 const tx = api.tx.nft.addToContractWhiteList(contractAddress, user);544 const events = await submitTransactionAsync(sender, tx);545 const result = getGenericResult(events);546547 expect(result.success).to.be.true;548 });549}550551export async function removeFromContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {552 await usingApi(async (api) => {553 const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);554 const events = await submitTransactionAsync(sender, tx);555 const result = getGenericResult(events);556557 expect(result.success).to.be.true;558 });559}560561export async function removeFromContractWhiteListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {562 await usingApi(async (api) => {563 const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);564 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;565 const result = getGenericResult(events);566567 expect(result.success).to.be.false;568 });569}570571export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {572 await usingApi(async (api) => {573 const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));574 const events = await submitTransactionAsync(sender, tx);575 const result = getGenericResult(events);576577 expect(result.success).to.be.true;578 });579}580581export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {582 await usingApi(async (api) => {583 const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));584 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;585 });586}587588export async function setOffchainSchemaExpectSuccess(sender: IKeyringPair, collectionId: number, data: number[]) {589 await usingApi(async (api) => {590 const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));591 const events = await submitTransactionAsync(sender, tx);592 const result = getGenericResult(events);593594 expect(result.success).to.be.true;595 });596}597598export async function setOffchainSchemaExpectFailure(sender: IKeyringPair, collectionId: number, data: number[]) {599 await usingApi(async (api) => {600 const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));601 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;602 });603}604605export interface CreateFungibleData {606 readonly Value: bigint;607}608609export interface CreateReFungibleData { }610export interface CreateNftData { }611612export type CreateItemData = {613 NFT: CreateNftData;614} | {615 Fungible: CreateFungibleData;616} | {617 ReFungible: CreateReFungibleData;618};619620export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {621 await usingApi(async (api) => {622 const tx = api.tx.nft.burnItem(collectionId, tokenId, value);623 const events = await submitTransactionAsync(owner, tx);624 const result = getGenericResult(events);625 // Get the item626 const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();627 // What to expect628 // tslint:disable-next-line:no-unused-expression629 expect(result.success).to.be.true;630 // tslint:disable-next-line:no-unused-expression631 expect(item).to.be.null;632 });633}634635export async function636approveExpectSuccess(collectionId: number,637 tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1) {638 await usingApi(async (api: ApiPromise) => {639 const allowanceBefore =640 await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;641 const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);642 const events = await submitTransactionAsync(owner, approveNftTx);643 const result = getCreateItemResult(events);644 // tslint:disable-next-line:no-unused-expression645 expect(result.success).to.be.true;646 const allowanceAfter =647 await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;648 expect(allowanceAfter.sub(allowanceBefore).toString()).to.be.equal(amount.toString());649 });650}651652export async function653transferFromExpectSuccess(collectionId: number,654 tokenId: number,655 accountApproved: IKeyringPair,656 accountFrom: IKeyringPair,657 accountTo: IKeyringPair,658 value: number | bigint = 1,659 type: string = 'NFT') {660 await usingApi(async (api: ApiPromise) => {661 let balanceBefore = new BN(0);662 if (type === 'Fungible') {663 balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;664 }665 const transferFromTx = await api.tx.nft.transferFrom(666 accountFrom.address, accountTo.address, collectionId, tokenId, value);667 const events = await submitTransactionAsync(accountApproved, transferFromTx);668 const result = getCreateItemResult(events);669 // tslint:disable-next-line:no-unused-expression670 expect(result.success).to.be.true;671 if (type === 'NFT') {672 const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap() as ITokenDataType;673 expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);674 }675 if (type === 'Fungible') {676 const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, accountTo.address) as any).Value as unknown as BN;677 expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());678 }679 if (type === 'ReFungible') {680 const nftItemData =681 (await api.query.nft.reFungibleItemList(collectionId, tokenId) as any).unwrap() as IReFungibleTokenDataType;682 expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);683 expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);684 }685 });686}687688export async function689transferFromExpectFail(collectionId: number,690 tokenId: number,691 accountApproved: IKeyringPair,692 accountFrom: IKeyringPair,693 accountTo: IKeyringPair,694 value: number | bigint = 1) {695 await usingApi(async (api: ApiPromise) => {696 const transferFromTx = await api.tx.nft.transferFrom(697 accountFrom.address, accountTo.address, collectionId, tokenId, value);698 const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;699 const result = getCreateCollectionResult(events);700 // tslint:disable-next-line:no-unused-expression701 expect(result.success).to.be.false;702 });703}704705export async function706transferExpectSuccess(collectionId: number,707 tokenId: number,708 sender: IKeyringPair,709 recipient: IKeyringPair,710 value: number | bigint = 1,711 type: string = 'NFT') {712 await usingApi(async (api: ApiPromise) => {713 let balanceBefore = new BN(0);714 if (type === 'Fungible') {715 balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;716 }717 const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);718 const events = await submitTransactionAsync(sender, transferTx);719 const result = getTransferResult(events);720 // tslint:disable-next-line:no-unused-expression721 expect(result.success).to.be.true;722 expect(result.collectionId).to.be.equal(collectionId);723 expect(result.itemId).to.be.equal(tokenId);724 expect(result.sender).to.be.equal(sender.address);725 expect(result.recipient).to.be.equal(recipient.address);726 expect(result.value.toString()).to.be.equal(value.toString());727 if (type === 'NFT') {728 const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;729 expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);730 }731 if (type === 'Fungible') {732 const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, recipient.address) as any).Value as unknown as BN;733 expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());734 }735 if (type === 'ReFungible') {736 const nftItemData =737 (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;738 expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);739 expect(nftItemData.Owner[0].Fraction.toString()).to.be.equal(value.toString());740 }741 });742}743744export async function745transferExpectFail(collectionId: number,746 tokenId: number,747 sender: IKeyringPair,748 recipient: IKeyringPair,749 value: number | bigint = 1,750 type: string = 'NFT') {751 await usingApi(async (api: ApiPromise) => {752 const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);753 const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;754 if (events && Array.isArray(events)) {755 const result = getCreateCollectionResult(events);756 // tslint:disable-next-line:no-unused-expression757 expect(result.success).to.be.false;758 }759 });760}761762export async function763approveExpectFail(collectionId: number,764 tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1) {765 await usingApi(async (api: ApiPromise) => {766 const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);767 const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;768 const result = getCreateCollectionResult(events);769 // tslint:disable-next-line:no-unused-expression770 expect(result.success).to.be.false;771 });772}773774export async function getFungibleBalance(775 collectionId: number,776 owner: string,777) {778 return await usingApi(async (api) => {779 const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as {Value: string};780 return BigInt(response.Value);781 });782}783784export async function createFungibleItemExpectSuccess(785 sender: IKeyringPair,786 collectionId: number,787 data: CreateFungibleData,788 owner: string = sender.address,789) {790 return await usingApi(async (api) => {791 const tx = api.tx.nft.createItem(collectionId, owner, { Fungible: data });792793 const events = await submitTransactionAsync(sender, tx);794 const result = getCreateItemResult(events);795796 expect(result.success).to.be.true;797 return result.itemId;798 });799}800801export async function createItemExpectSuccess(802 sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {803 let newItemId: number = 0;804 await usingApi(async (api) => {805 const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);806 const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();807 const AItemBalance = new BigNumber(Aitem.Value);808809 if (owner === '') {810 owner = sender.address;811 }812813 let tx;814 if (createMode === 'Fungible') {815 const createData = {fungible: {value: 10}};816 tx = api.tx.nft.createItem(collectionId, owner, createData);817 } else if (createMode === 'ReFungible') {818 const createData = {refungible: {const_data: [], variable_data: [], pieces: 100}};819 tx = api.tx.nft.createItem(collectionId, owner, createData);820 } else {821 tx = api.tx.nft.createItem(collectionId, owner, createMode);822 }823 const events = await submitTransactionAsync(sender, tx);824 const result = getCreateItemResult(events);825826 const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);827 const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();828 const BItemBalance = new BigNumber(Bitem.Value);829830 // What to expect831 // tslint:disable-next-line:no-unused-expression832 expect(result.success).to.be.true;833 if (createMode === 'Fungible') {834 expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);835 } else {836 expect(BItemCount).to.be.equal(AItemCount + 1);837 }838 expect(collectionId).to.be.equal(result.collectionId);839 expect(BItemCount).to.be.equal(result.itemId);840 expect(owner).to.be.equal(result.recipient);841 newItemId = result.itemId;842 });843 return newItemId;844}845846export async function createItemExpectFailure(847 sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {848 await usingApi(async (api) => {849 const tx = api.tx.nft.createItem(collectionId, owner, createMode);850 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;851 const result = getCreateItemResult(events);852853 expect(result.success).to.be.false;854 });855}856857export async function setPublicAccessModeExpectSuccess(858 sender: IKeyringPair, collectionId: number,859 accessMode: 'Normal' | 'WhiteList',860) {861 await usingApi(async (api) => {862863 // Run the transaction864 const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);865 const events = await submitTransactionAsync(sender, tx);866 const result = getGenericResult(events);867868 // Get the collection869 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();870871 // What to expect872 // tslint:disable-next-line:no-unused-expression873 expect(result.success).to.be.true;874 expect(collection.Access).to.be.equal(accessMode);875 });876}877878export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {879 await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');880}881882export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {883 await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');884}885886export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {887 await usingApi(async (api) => {888889 // Run the transaction890 const tx = api.tx.nft.setMintPermission(collectionId, enabled);891 const events = await submitTransactionAsync(sender, tx);892 const result = getGenericResult(events);893894 // Get the collection895 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();896897 // What to expect898 // tslint:disable-next-line:no-unused-expression899 expect(result.success).to.be.true;900 expect(collection.MintMode).to.be.equal(enabled);901 });902}903904export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {905 await setMintPermissionExpectSuccess(sender, collectionId, true);906}907908export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {909 await usingApi(async (api) => {910 // Run the transaction911 const tx = api.tx.nft.setMintPermission(collectionId, enabled);912 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;913 const result = getCreateCollectionResult(events);914 // tslint:disable-next-line:no-unused-expression915 expect(result.success).to.be.false;916 });917}918919export async function isWhitelisted(collectionId: number, address: string) {920 let whitelisted: boolean = false;921 await usingApi(async (api) => {922 whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;923 });924 return whitelisted;925}926927export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {928 await usingApi(async (api) => {929930 const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();931932 // Run the transaction933 const tx = api.tx.nft.addToWhiteList(collectionId, address);934 const events = await submitTransactionAsync(sender, tx);935 const result = getGenericResult(events);936937 const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();938939 // What to expect940 // tslint:disable-next-line:no-unused-expression941 expect(result.success).to.be.true;942 // tslint:disable-next-line: no-unused-expression943 expect(whiteListedBefore).to.be.false;944 // tslint:disable-next-line: no-unused-expression945 expect(whiteListedAfter).to.be.true;946 });947}948949export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {950 await usingApi(async (api) => {951 // Run the transaction952 const tx = api.tx.nft.removeFromWhiteList(collectionId, address);953 const events = await submitTransactionAsync(sender, tx);954 const result = getGenericResult(events);955956 // What to expect957 // tslint:disable-next-line:no-unused-expression958 expect(result.success).to.be.true;959 });960}961962export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: string) {963 await usingApi(async (api) => {964 // Run the transaction965 const tx = api.tx.nft.removeFromWhiteList(collectionId, address);966 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;967 const result = getGenericResult(events);968969 // What to expect970 // tslint:disable-next-line:no-unused-expression971 expect(result.success).to.be.false;972 });973}974975export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)976 : Promise<ICollectionInterface | null> => {977 return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;978};979980export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {981 // set global object - collectionsCount982 return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();983};984985export async function queryCollectionExpectSuccess(collectionId: number): Promise<ICollectionInterface> {986 return await usingApi(async (api) => {987 return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;988 });989}