difftreelog
feat add ApproveForAll to Eth and Sub
in: master
39 files changed
client/rpc/src/lib.rsdiffbeforeafterboth--- a/client/rpc/src/lib.rs
+++ b/client/rpc/src/lib.rs
@@ -246,6 +246,16 @@
token_id: TokenId,
at: Option<BlockHash>,
) -> Result<Option<String>>;
+
+ /// Get whether an operator is approved by a given owner.
+ #[method(name = "unique_isApprovedForAll")]
+ fn is_approved_for_all(
+ &self,
+ collection: CollectionId,
+ owner: CrossAccountId,
+ operator: CrossAccountId,
+ at: Option<BlockHash>,
+ ) -> Result<bool>;
}
mod app_promotion_unique_rpc {
@@ -569,6 +579,7 @@
pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>, unique_api);
pass_method!(total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<String> => |o| o.map(|number| number.to_string()) , unique_api);
pass_method!(token_owners(collection: CollectionId, token: TokenId) -> Vec<CrossAccountId>, unique_api);
+ pass_method!(is_approved_for_all(collection: CollectionId, owner: CrossAccountId, operator: CrossAccountId) -> bool, unique_api);
}
impl<C, Block, BlockNumber, CrossAccountId, AccountId>
pallets/common/src/lib.rsdiffbeforeafterboth--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -472,6 +472,18 @@
u128,
),
+ /// Amount pieces of token owned by `sender` was approved for `spender`.
+ ApprovedForAll(
+ /// Id of collection to which item is belong.
+ CollectionId,
+ /// Owner of a wallet.
+ T::CrossAccountId,
+ /// Id for which operator status was granted or rewoked.
+ T::CrossAccountId,
+ /// Is operator status was granted or rewoked.
+ bool,
+ ),
+
/// The colletion property has been added or edited.
CollectionPropertySet(
/// Id of collection to which property has been set.
@@ -1521,6 +1533,9 @@
/// The price of retrieving token owner
fn token_owner() -> Weight;
+
+ /// The price of setting approval for all
+ fn set_approval_for_all() -> Weight;
}
/// Weight info extension trait for refungible pallet.
@@ -1828,6 +1843,20 @@
/// Get extension for RFT collection.
fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;
+
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ /// * `owner` - Token owner
+ /// * `operator` - Operator
+ /// * `approve` - Is operator enabled or disabled
+ fn set_approval_for_all(
+ &self,
+ owner: T::CrossAccountId,
+ operator: T::CrossAccountId,
+ approve: bool,
+ ) -> DispatchResultWithPostInfo;
+
+ /// Tells whether an operator is approved by a given owner.
+ fn is_approved_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool;
}
/// Extension for RFT collection.
pallets/fungible/src/common.rsdiffbeforeafterboth--- a/pallets/fungible/src/common.rs
+++ b/pallets/fungible/src/common.rs
@@ -107,6 +107,10 @@
fn token_owner() -> Weight {
Weight::zero()
}
+
+ fn set_approval_for_all() -> Weight {
+ Weight::zero()
+ }
}
/// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete
@@ -424,4 +428,17 @@
}
<TotalSupply<T>>::try_get(self.id).ok()
}
+
+ fn set_approval_for_all(
+ &self,
+ _owner: T::CrossAccountId,
+ _operator: T::CrossAccountId,
+ _approve: bool,
+ ) -> DispatchResultWithPostInfo {
+ fail!(<Error<T>>::SettingApprovalForAllNotAllowed)
+ }
+
+ fn is_approved_for_all(&self, _owner: T::CrossAccountId, _operator: T::CrossAccountId) -> bool {
+ false
+ }
}
pallets/fungible/src/lib.rsdiffbeforeafterboth--- a/pallets/fungible/src/lib.rs
+++ b/pallets/fungible/src/lib.rs
@@ -127,6 +127,8 @@
FungibleDisallowsNesting,
/// Setting item properties is not allowed.
SettingPropertiesNotAllowed,
+ /// Setting approval for all is not allowed.
+ SettingApprovalForAllNotAllowed,
}
#[pallet::config]
pallets/nonfungible/src/benchmarking.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/src/benchmarking.rs
@@ -222,4 +222,18 @@
let item = create_max_item(&collection, &owner, owner.clone())?;
}: {collection.token_owner(item)}
+
+ set_approval_for_all {
+ bench_init!{
+ owner: sub; collection: collection(owner);
+ operator: cross_from_sub(owner); owner: cross_sub;
+ };
+ }: {<Pallet<T>>::set_approval_for_all(&collection, &owner, &operator, true)}
+
+ is_approved_for_all {
+ bench_init!{
+ owner: sub; collection: collection(owner);
+ operator: cross_from_sub(owner); owner: cross_sub;
+ };
+ }: {<Pallet<T>>::is_approved_for_all(&collection, &owner, &operator)}
}
pallets/nonfungible/src/common.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/common.rs
+++ b/pallets/nonfungible/src/common.rs
@@ -122,6 +122,10 @@
fn token_owner() -> Weight {
<SelfWeightOf<T>>::token_owner()
}
+
+ fn set_approval_for_all() -> Weight {
+ <SelfWeightOf<T>>::set_approval_for_all()
+ }
}
fn map_create_data<T: Config>(
@@ -512,4 +516,20 @@
None
}
}
+
+ fn set_approval_for_all(
+ &self,
+ owner: T::CrossAccountId,
+ operator: T::CrossAccountId,
+ approve: bool,
+ ) -> DispatchResultWithPostInfo {
+ with_weight(
+ <Pallet<T>>::set_approval_for_all(self, &owner, &operator, approve),
+ <CommonWeights<T>>::set_approval_for_all(),
+ )
+ }
+
+ fn is_approved_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {
+ <Pallet<T>>::is_approved_for_all(self, &owner, &operator)
+ }
}
pallets/nonfungible/src/erc.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -469,15 +469,23 @@
Ok(())
}
- /// @dev Not implemented
+ /// @notice Sets or unsets the approval of a given operator.
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ /// @param operator Operator
+ /// @param approved Is operator enabled or disabled
+ #[weight(<SelfWeightOf<T>>::set_approval_for_all())]
fn set_approval_for_all(
&mut self,
- _caller: caller,
- _operator: address,
- _approved: bool,
+ caller: caller,
+ operator: address,
+ approved: bool,
) -> Result<void> {
- // TODO: Not implemetable
- Err("not implemented".into())
+ let caller = T::CrossAccountId::from_eth(caller);
+ let operator = T::CrossAccountId::from_eth(operator);
+
+ <Pallet<T>>::set_approval_for_all(self, &caller, &operator, approved)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(())
}
/// @dev Not implemented
@@ -486,10 +494,13 @@
Err("not implemented".into())
}
- /// @dev Not implemented
- fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
- // TODO: Not implemetable
- Err("not implemented".into())
+ /// @notice Tells whether an operator is approved by a given owner.
+ #[weight(<SelfWeightOf<T>>::is_approved_for_all())]
+ fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {
+ let owner = T::CrossAccountId::from_eth(owner);
+ let operator = T::CrossAccountId::from_eth(operator);
+
+ Ok(<Pallet<T>>::is_approved_for_all(self, &owner, &operator))
}
/// @notice Returns collection helper contract address
pallets/nonfungible/src/lib.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -272,6 +272,18 @@
QueryKind = OptionQuery,
>;
+ /// Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.
+ #[pallet::storage]
+ pub type WalletOperator<T: Config> = StorageNMap<
+ Key = (
+ Key<Twox64Concat, CollectionId>,
+ Key<Blake2_128Concat, T::CrossAccountId>,
+ Key<Blake2_128Concat, T::CrossAccountId>,
+ ),
+ Value = bool,
+ QueryKind = OptionQuery,
+ >;
+
/// Upgrade from the old schema to properties.
#[pallet::hooks]
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
@@ -438,6 +450,7 @@
<TokensBurnt<T>>::remove(id);
let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);
let _ = <AccountBalance<T>>::clear_prefix((id,), u32::MAX, None);
+ let _ = <WalletOperator<T>>::clear_prefix((id,), u32::MAX, None);
Ok(())
}
@@ -1193,6 +1206,9 @@
if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {
return Ok(());
}
+ if <WalletOperator<T>>::get((collection.id, from, spender)) == Some(true) {
+ return Ok(());
+ }
ensure!(
collection.ignores_allowance(spender),
<CommonError<T>>::ApprovedValueTooLow
@@ -1326,4 +1342,52 @@
) -> DispatchResult {
Self::create_multiple_items(collection, sender, vec![data], nesting_budget)
}
+
+ /// Sets or unsets the approval of a given operator.
+ ///
+ /// An operator is allowed to transfer all token pieces of the sender on their behalf.
+ /// - `owner`: Token owner
+ /// - `operator`: Operator
+ /// - `approve`: Is operator enabled or disabled
+ pub fn set_approval_for_all(
+ collection: &NonfungibleHandle<T>,
+ owner: &T::CrossAccountId,
+ operator: &T::CrossAccountId,
+ approve: bool,
+ ) -> DispatchResult {
+ if collection.permissions.access() == AccessMode::AllowList {
+ collection.check_allowlist(owner)?;
+ collection.check_allowlist(operator)?;
+ }
+
+ <PalletCommon<T>>::ensure_correct_receiver(operator)?;
+
+ // =========
+
+ <WalletOperator<T>>::insert((collection.id, owner, operator), approve);
+ <PalletEvm<T>>::deposit_log(
+ ERC721Events::ApprovalForAll {
+ owner: *owner.as_eth(),
+ operator: *operator.as_eth(),
+ approved: approve,
+ }
+ .to_log(collection_id_to_address(collection.id)),
+ );
+ <PalletCommon<T>>::deposit_event(CommonEvent::ApprovedForAll(
+ collection.id,
+ owner.clone(),
+ operator.clone(),
+ approve,
+ ));
+ Ok(())
+ }
+
+ /// Tells whether an operator is approved by a given owner.
+ pub fn is_approved_for_all(
+ collection: &NonfungibleHandle<T>,
+ owner: &T::CrossAccountId,
+ operator: &T::CrossAccountId,
+ ) -> bool {
+ <WalletOperator<T>>::get((collection.id, owner, operator)).unwrap_or(false)
+ }
}
pallets/nonfungible/src/stubs/UniqueNFT.rawdiffbeforeafterbothbinary blob — no preview
pallets/nonfungible/src/stubs/UniqueNFT.soldiffbeforeafterboth--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -1020,7 +1020,10 @@
dummy = 0;
}
- /// @dev Not implemented
+ /// @notice Sets or unsets the approval of a given operator.
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ /// @param operator Operator
+ /// @param approved Is operator enabled or disabled
/// @dev EVM selector for this function is: 0xa22cb465,
/// or in textual repr: setApprovalForAll(address,bool)
function setApprovalForAll(address operator, bool approved) public {
@@ -1040,15 +1043,15 @@
return 0x0000000000000000000000000000000000000000;
}
- /// @dev Not implemented
+ /// @notice Tells whether an operator is approved by a given owner.
/// @dev EVM selector for this function is: 0xe985e9c5,
/// or in textual repr: isApprovedForAll(address,address)
- function isApprovedForAll(address owner, address operator) public view returns (address) {
+ function isApprovedForAll(address owner, address operator) public view returns (bool) {
require(false, stub_error);
owner;
operator;
dummy;
- return 0x0000000000000000000000000000000000000000;
+ return false;
}
/// @notice Returns collection helper contract address
pallets/nonfungible/src/weights.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/weights.rs
+++ b/pallets/nonfungible/src/weights.rs
@@ -26,6 +26,7 @@
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(unused_parens)]
#![allow(unused_imports)]
+#![allow(missing_docs)]
#![allow(clippy::unnecessary_cast)]
use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
@@ -47,6 +48,8 @@
fn set_token_properties(b: u32, ) -> Weight;
fn delete_token_properties(b: u32, ) -> Weight;
fn token_owner() -> Weight;
+ fn set_approval_for_all() -> Weight;
+ fn is_approved_for_all() -> Weight;
}
/// Weights for pallet_nonfungible using the Substrate node and recommended hardware.
@@ -195,6 +198,16 @@
Weight::from_ref_time(4_366_000)
.saturating_add(T::DbWeight::get().reads(1 as u64))
}
+ // Storage: Nonfungible WalletOperator (r:0 w:1)
+ fn set_approval_for_all() -> Weight {
+ Weight::from_ref_time(16_231_000 as u64)
+ .saturating_add(T::DbWeight::get().writes(1 as u64))
+ }
+ // Storage: Nonfungible WalletOperator (r:1 w:0)
+ fn is_approved_for_all() -> Weight {
+ Weight::from_ref_time(6_161_000 as u64)
+ .saturating_add(T::DbWeight::get().reads(1 as u64))
+ }
}
// For backwards compatibility and tests
@@ -342,4 +355,14 @@
Weight::from_ref_time(4_366_000)
.saturating_add(RocksDbWeight::get().reads(1 as u64))
}
+ // Storage: Nonfungible WalletOperator (r:0 w:1)
+ fn set_approval_for_all() -> Weight {
+ Weight::from_ref_time(16_231_000 as u64)
+ .saturating_add(RocksDbWeight::get().writes(1 as u64))
+ }
+ // Storage: Nonfungible WalletOperator (r:1 w:0)
+ fn is_approved_for_all() -> Weight {
+ Weight::from_ref_time(6_161_000 as u64)
+ .saturating_add(RocksDbWeight::get().reads(1 as u64))
+ }
}
pallets/refungible/src/benchmarking.rsdiffbeforeafterboth--- a/pallets/refungible/src/benchmarking.rs
+++ b/pallets/refungible/src/benchmarking.rs
@@ -290,4 +290,18 @@
};
let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?;
}: {<Pallet<T>>::token_owner(collection.id, item)}
+
+ set_approval_for_all {
+ bench_init!{
+ owner: sub; collection: collection(owner);
+ operator: cross_from_sub(owner); owner: cross_sub;
+ };
+ }: {<Pallet<T>>::set_approval_for_all(&collection, &owner, &operator, true)}
+
+ is_approved_for_all {
+ bench_init!{
+ owner: sub; collection: collection(owner);
+ operator: cross_from_sub(owner); owner: cross_sub;
+ };
+ }: {<Pallet<T>>::is_approved_for_all(&collection, &owner, &operator)}
}
pallets/refungible/src/common.rsdiffbeforeafterboth--- a/pallets/refungible/src/common.rs
+++ b/pallets/refungible/src/common.rs
@@ -152,6 +152,10 @@
fn token_owner() -> Weight {
<SelfWeightOf<T>>::token_owner()
}
+
+ fn set_approval_for_all() -> Weight {
+ <SelfWeightOf<T>>::set_approval_for_all()
+ }
}
fn map_create_data<T: Config>(
@@ -516,6 +520,22 @@
fn total_pieces(&self, token: TokenId) -> Option<u128> {
<Pallet<T>>::total_pieces(self.id, token)
}
+
+ fn set_approval_for_all(
+ &self,
+ owner: T::CrossAccountId,
+ operator: T::CrossAccountId,
+ approve: bool,
+ ) -> DispatchResultWithPostInfo {
+ with_weight(
+ <Pallet<T>>::set_approval_for_all(self, &owner, &operator, approve),
+ <CommonWeights<T>>::set_approval_for_all(),
+ )
+ }
+
+ fn is_approved_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {
+ <Pallet<T>>::is_approved_for_all(self, &owner, &operator)
+ }
}
impl<T: Config> RefungibleExtensions<T> for RefungibleHandle<T> {
pallets/refungible/src/erc.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -461,15 +461,23 @@
Err("not implemented".into())
}
- /// @dev Not implemented
+ /// @notice Sets or unsets the approval of a given operator.
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ /// @param operator Operator
+ /// @param approved Is operator enabled or disabled
+ #[weight(<SelfWeightOf<T>>::set_approval_for_all())]
fn set_approval_for_all(
&mut self,
- _caller: caller,
- _operator: address,
- _approved: bool,
+ caller: caller,
+ operator: address,
+ approved: bool,
) -> Result<void> {
- // TODO: Not implemetable
- Err("not implemented".into())
+ let caller = T::CrossAccountId::from_eth(caller);
+ let operator = T::CrossAccountId::from_eth(operator);
+
+ <Pallet<T>>::set_approval_for_all(self, &caller, &operator, approved)
+ .map_err(dispatch_to_evm::<T>)?;
+ Ok(())
}
/// @dev Not implemented
@@ -478,10 +486,13 @@
Err("not implemented".into())
}
- /// @dev Not implemented
- fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
- // TODO: Not implemetable
- Err("not implemented".into())
+ /// @notice Tells whether an operator is approved by a given owner.
+ #[weight(<SelfWeightOf<T>>::is_approved_for_all())]
+ fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {
+ let owner = T::CrossAccountId::from_eth(owner);
+ let operator = T::CrossAccountId::from_eth(operator);
+
+ Ok(<Pallet<T>>::is_approved_for_all(self, &owner, &operator))
}
/// @notice Returns collection helper contract address
pallets/refungible/src/lib.rsdiffbeforeafterboth--- a/pallets/refungible/src/lib.rs
+++ b/pallets/refungible/src/lib.rs
@@ -273,6 +273,18 @@
QueryKind = ValueQuery,
>;
+ /// Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.
+ #[pallet::storage]
+ pub type WalletOperator<T: Config> = StorageNMap<
+ Key = (
+ Key<Twox64Concat, CollectionId>,
+ Key<Blake2_128Concat, T::CrossAccountId>,
+ Key<Blake2_128Concat, T::CrossAccountId>,
+ ),
+ Value = bool,
+ QueryKind = OptionQuery,
+ >;
+
#[pallet::hooks]
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
fn on_runtime_upgrade() -> Weight {
@@ -1161,6 +1173,12 @@
}
let allowance =
<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);
+
+ // Allowance if any would be reduced if spender is also wallet operator
+ if <WalletOperator<T>>::get((collection.id, from, spender)) == Some(true) {
+ return Ok(allowance);
+ }
+
if allowance.is_none() {
ensure!(
collection.ignores_allowance(spender),
@@ -1387,4 +1405,52 @@
Some(res)
}
}
+
+ /// Sets or unsets the approval of a given operator.
+ ///
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ /// - `owner`: Token owner
+ /// - `operator`: Operator
+ /// - `approve`: Is operator enabled or disabled
+ pub fn set_approval_for_all(
+ collection: &RefungibleHandle<T>,
+ owner: &T::CrossAccountId,
+ operator: &T::CrossAccountId,
+ approve: bool,
+ ) -> DispatchResult {
+ if collection.permissions.access() == AccessMode::AllowList {
+ collection.check_allowlist(owner)?;
+ collection.check_allowlist(operator)?;
+ }
+
+ <PalletCommon<T>>::ensure_correct_receiver(operator)?;
+
+ // =========
+
+ <WalletOperator<T>>::insert((collection.id, owner, operator), approve);
+ <PalletEvm<T>>::deposit_log(
+ ERC721Events::ApprovalForAll {
+ owner: *owner.as_eth(),
+ operator: *operator.as_eth(),
+ approved: approve,
+ }
+ .to_log(collection_id_to_address(collection.id)),
+ );
+ <PalletCommon<T>>::deposit_event(CommonEvent::ApprovedForAll(
+ collection.id,
+ owner.clone(),
+ operator.clone(),
+ approve,
+ ));
+ Ok(())
+ }
+
+ /// Tells whether an operator is approved by a given owner.
+ pub fn is_approved_for_all(
+ collection: &RefungibleHandle<T>,
+ owner: &T::CrossAccountId,
+ operator: &T::CrossAccountId,
+ ) -> bool {
+ <WalletOperator<T>>::get((collection.id, owner, operator)).unwrap_or(false)
+ }
}
pallets/refungible/src/stubs/UniqueRefungible.rawdiffbeforeafterbothbinary blob — no preview
pallets/refungible/src/stubs/UniqueRefungible.soldiffbeforeafterboth--- a/pallets/refungible/src/stubs/UniqueRefungible.sol
+++ b/pallets/refungible/src/stubs/UniqueRefungible.sol
@@ -1017,7 +1017,10 @@
dummy = 0;
}
- /// @dev Not implemented
+ /// @notice Sets or unsets the approval of a given operator.
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ /// @param operator Operator
+ /// @param approved Is operator enabled or disabled
/// @dev EVM selector for this function is: 0xa22cb465,
/// or in textual repr: setApprovalForAll(address,bool)
function setApprovalForAll(address operator, bool approved) public {
@@ -1037,15 +1040,15 @@
return 0x0000000000000000000000000000000000000000;
}
- /// @dev Not implemented
+ /// @notice Tells whether an operator is approved by a given owner.
/// @dev EVM selector for this function is: 0xe985e9c5,
/// or in textual repr: isApprovedForAll(address,address)
- function isApprovedForAll(address owner, address operator) public view returns (address) {
+ function isApprovedForAll(address owner, address operator) public view returns (bool) {
require(false, stub_error);
owner;
operator;
dummy;
- return 0x0000000000000000000000000000000000000000;
+ return false;
}
/// @notice Returns collection helper contract address
pallets/refungible/src/weights.rsdiffbeforeafterboth--- a/pallets/refungible/src/weights.rs
+++ b/pallets/refungible/src/weights.rs
@@ -3,7 +3,7 @@
//! Autogenerated weights for pallet_refungible
//!
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2022-08-15, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2022-11-25, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
// Executed Command:
@@ -26,6 +26,7 @@
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(unused_parens)]
#![allow(unused_imports)]
+#![allow(missing_docs)]
#![allow(clippy::unnecessary_cast)]
use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
@@ -54,6 +55,8 @@
fn delete_token_properties(b: u32, ) -> Weight;
fn repartition_item() -> Weight;
fn token_owner() -> Weight;
+ fn set_approval_for_all() -> Weight;
+ fn is_approved_for_all() -> Weight;
}
/// Weights for pallet_refungible using the Substrate node and recommended hardware.
@@ -259,6 +262,16 @@
Weight::from_ref_time(9_431_000)
.saturating_add(T::DbWeight::get().reads(2 as u64))
}
+ // Storage: Refungible WalletOperator (r:0 w:1)
+ fn set_approval_for_all() -> Weight {
+ Weight::from_ref_time(16_150_000 as u64)
+ .saturating_add(T::DbWeight::get().writes(1 as u64))
+ }
+ // Storage: Refungible WalletOperator (r:1 w:0)
+ fn is_approved_for_all() -> Weight {
+ Weight::from_ref_time(5_901_000 as u64)
+ .saturating_add(T::DbWeight::get().reads(1 as u64))
+ }
}
// For backwards compatibility and tests
@@ -463,4 +476,14 @@
Weight::from_ref_time(9_431_000)
.saturating_add(RocksDbWeight::get().reads(2 as u64))
}
+ // Storage: Refungible WalletOperator (r:0 w:1)
+ fn set_approval_for_all() -> Weight {
+ Weight::from_ref_time(16_150_000 as u64)
+ .saturating_add(RocksDbWeight::get().writes(1 as u64))
+ }
+ // Storage: Refungible WalletOperator (r:1 w:0)
+ fn is_approved_for_all() -> Weight {
+ Weight::from_ref_time(5_901_000 as u64)
+ .saturating_add(RocksDbWeight::get().reads(1 as u64))
+ }
}
pallets/unique/src/lib.rsdiffbeforeafterboth--- a/pallets/unique/src/lib.rs
+++ b/pallets/unique/src/lib.rs
@@ -1126,6 +1126,28 @@
}
})
}
+
+ /// Sets or unsets the approval of a given operator.
+ ///
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ ///
+ /// # Arguments
+ ///
+ /// * `owner`: Token owner
+ /// * `operator`: Operator
+ /// * `approve`: Is operator enabled or disabled
+ #[weight = T::CommonWeightInfo::set_approval_for_all()]
+ pub fn set_approval_for_all(
+ origin,
+ collection_id: CollectionId,
+ operator: T::CrossAccountId,
+ approve: bool,
+ ) -> DispatchResultWithPostInfo {
+ let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.set_approval_for_all(sender, operator, approve)
+ })
+ }
}
}
primitives/rpc/src/lib.rsdiffbeforeafterboth--- a/primitives/rpc/src/lib.rs
+++ b/primitives/rpc/src/lib.rs
@@ -132,5 +132,8 @@
fn total_pieces(collection_id: CollectionId, token_id: TokenId) -> Result<Option<u128>>;
fn token_owners(collection: CollectionId, token: TokenId) -> Result<Vec<CrossAccountId>>;
+
+ /// Get whether an operator is approved by a given owner.
+ fn is_approved_for_all(collection: CollectionId, owner: CrossAccountId, operator: CrossAccountId) -> Result<bool>;
}
}
runtime/common/runtime_apis.rsdiffbeforeafterboth--- a/runtime/common/runtime_apis.rs
+++ b/runtime/common/runtime_apis.rs
@@ -187,6 +187,10 @@
fn total_pieces(collection: CollectionId, token_id: TokenId) -> Result<Option<u128>, DispatchError> {
dispatch_unique_runtime!(collection.total_pieces(token_id))
}
+
+ fn is_approved_for_all(collection: CollectionId, owner: CrossAccountId, operator: CrossAccountId) -> Result<bool, DispatchError> {
+ dispatch_unique_runtime!(collection.is_approved_for_all(owner, operator))
+ }
}
impl app_promotion_rpc::AppPromotionApi<Block, BlockNumber, CrossAccountId, AccountId> for Runtime {
runtime/common/weights.rsdiffbeforeafterboth--- a/runtime/common/weights.rs
+++ b/runtime/common/weights.rs
@@ -120,6 +120,10 @@
fn token_owner() -> Weight {
max_weight_of!(token_owner())
}
+
+ fn set_approval_for_all() -> Weight {
+ max_weight_of!(set_approval_for_all())
+ }
}
#[cfg(feature = "refungible")]
tests/src/approve.test.tsdiffbeforeafterboth--- a/tests/src/approve.test.ts
+++ b/tests/src/approve.test.ts
@@ -603,3 +603,40 @@
await expect(approveTx()).to.be.rejected;
});
});
+
+describe('Normal user can approve other users to be wallet operator:', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = await privateKey({filename: __filename});
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
+ });
+ });
+
+ itSub('[nft] Enable and disable approval', async ({helper}) => {
+ const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
+ const checkBeforeApprovalTx = () => helper.nft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
+ expect(await checkBeforeApprovalTx()).to.be.false;
+ await helper.nft.setApprovalForAll(alice, collectionId, {Substrate: bob.address}, true);
+ const checkAfterApprovalTx = () => helper.nft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
+ expect(await checkAfterApprovalTx()).to.be.true;
+ await helper.nft.setApprovalForAll(alice, collectionId, {Substrate: bob.address}, false);
+ const checkAfterDisapprovalTx = () => helper.nft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
+ expect(await checkAfterDisapprovalTx()).to.be.false;
+ });
+
+ itSub.ifWithPallets('[rft] Enable and disable approval', [Pallets.ReFungible], async ({helper}) => {
+ const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const checkBeforeApprovalTx = () => helper.rft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
+ expect(await checkBeforeApprovalTx()).to.be.false;
+ await helper.rft.setApprovalForAll(alice, collectionId, {Substrate: bob.address}, true);
+ const checkAfterApprovalTx = () => helper.rft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
+ expect(await checkAfterApprovalTx()).to.be.true;
+ await helper.rft.setApprovalForAll(alice, collectionId, {Substrate: bob.address}, false);
+ const checkAfterDisapprovalTx = () => helper.rft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
+ expect(await checkAfterDisapprovalTx()).to.be.false;
+ });
+});
tests/src/eth/abi/nonFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/nonFungible.json
+++ b/tests/src/eth/abi/nonFungible.json
@@ -384,7 +384,7 @@
{ "internalType": "address", "name": "operator", "type": "address" }
],
"name": "isApprovedForAll",
- "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
"stateMutability": "view",
"type": "function"
},
tests/src/eth/abi/reFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/reFungible.json
+++ b/tests/src/eth/abi/reFungible.json
@@ -366,7 +366,7 @@
{ "internalType": "address", "name": "operator", "type": "address" }
],
"name": "isApprovedForAll",
- "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
+ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
"stateMutability": "view",
"type": "function"
},
tests/src/eth/api/UniqueNFT.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -671,7 +671,10 @@
/// or in textual repr: approve(address,uint256)
function approve(address approved, uint256 tokenId) external;
- /// @dev Not implemented
+ /// @notice Sets or unsets the approval of a given operator.
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ /// @param operator Operator
+ /// @param approved Is operator enabled or disabled
/// @dev EVM selector for this function is: 0xa22cb465,
/// or in textual repr: setApprovalForAll(address,bool)
function setApprovalForAll(address operator, bool approved) external;
@@ -681,10 +684,10 @@
/// or in textual repr: getApproved(uint256)
function getApproved(uint256 tokenId) external view returns (address);
- /// @dev Not implemented
+ /// @notice Tells whether an operator is approved by a given owner.
/// @dev EVM selector for this function is: 0xe985e9c5,
/// or in textual repr: isApprovedForAll(address,address)
- function isApprovedForAll(address owner, address operator) external view returns (address);
+ function isApprovedForAll(address owner, address operator) external view returns (bool);
/// @notice Returns collection helper contract address
/// @dev EVM selector for this function is: 0x1896cce6,
tests/src/eth/api/UniqueRefungible.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueRefungible.sol
+++ b/tests/src/eth/api/UniqueRefungible.sol
@@ -668,7 +668,10 @@
/// or in textual repr: approve(address,uint256)
function approve(address approved, uint256 tokenId) external;
- /// @dev Not implemented
+ /// @notice Sets or unsets the approval of a given operator.
+ /// An operator is allowed to transfer all tokens of the sender on their behalf.
+ /// @param operator Operator
+ /// @param approved Is operator enabled or disabled
/// @dev EVM selector for this function is: 0xa22cb465,
/// or in textual repr: setApprovalForAll(address,bool)
function setApprovalForAll(address operator, bool approved) external;
@@ -678,10 +681,10 @@
/// or in textual repr: getApproved(uint256)
function getApproved(uint256 tokenId) external view returns (address);
- /// @dev Not implemented
+ /// @notice Tells whether an operator is approved by a given owner.
/// @dev EVM selector for this function is: 0xe985e9c5,
/// or in textual repr: isApprovedForAll(address,address)
- function isApprovedForAll(address owner, address operator) external view returns (address);
+ function isApprovedForAll(address owner, address operator) external view returns (bool);
/// @notice Returns collection helper contract address
/// @dev EVM selector for this function is: 0x1896cce6,
tests/src/eth/nonFungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/nonFungible.test.ts
+++ b/tests/src/eth/nonFungible.test.ts
@@ -249,6 +249,114 @@
}
});
+ itEth('Can perform setApprovalForAll()', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const operator = helper.eth.createAccount();
+
+ const collection = await helper.nft.mintCollection(minter, {});
+
+ const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
+
+ const approvedBefore = await contract.methods.isApprovedForAll(owner, operator).call();
+ expect(approvedBefore).to.be.equal(false);
+
+ {
+ const result = await contract.methods.setApprovalForAll(operator, true).send({from: owner});
+
+ expect(result.events.ApprovalForAll).to.be.like({
+ address: collectionAddress,
+ event: 'ApprovalForAll',
+ returnValues: {
+ owner,
+ operator,
+ approved: true,
+ },
+ });
+
+ const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();
+ expect(approvedAfter).to.be.equal(true);
+ }
+
+ {
+ const result = await contract.methods.setApprovalForAll(operator, false).send({from: owner});
+
+ expect(result.events.ApprovalForAll).to.be.like({
+ address: collectionAddress,
+ event: 'ApprovalForAll',
+ returnValues: {
+ owner,
+ operator,
+ approved: false,
+ },
+ });
+
+ const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();
+ expect(approvedAfter).to.be.equal(false);
+ }
+ });
+
+ itEth('Can perform burn with ApprovalForAll', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const operator = await helper.eth.createAccountWithBalance(donor, 100n);
+
+ const token = await collection.mintToken(minter, {Ethereum: owner});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'nft');
+
+ {
+ await contract.methods.setApprovalForAll(operator, true).send({from: owner});
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: operator});
+ const events = result.events.Transfer;
+
+ expect(events).to.be.like({
+ address,
+ event: 'Transfer',
+ returnValues: {
+ from: owner,
+ to: '0x0000000000000000000000000000000000000000',
+ tokenId: token.tokenId.toString(),
+ },
+ });
+ }
+ });
+
+ itEth('Can perform transfer with ApprovalForAll', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const operator = await helper.eth.createAccountWithBalance(donor);
+ const receiver = charlie;
+
+ const token = await collection.mintToken(minter, {Ethereum: owner});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'nft');
+
+ {
+ await contract.methods.setApprovalForAll(operator, true).send({from: owner});
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);
+ const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: operator});
+ const event = result.events.Transfer;
+ expect(event).to.be.like({
+ address: helper.ethAddress.fromCollectionId(collection.collectionId),
+ event: 'Transfer',
+ returnValues: {
+ from: owner,
+ to: helper.address.substrateToEth(receiver.address),
+ tokenId: token.tokenId.toString(),
+ },
+ });
+ }
+
+ expect(await token.getOwner()).to.be.like({Substrate: receiver.address});
+ });
+
itEth('Can perform burnFromCross()', async ({helper}) => {
const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
const ownerSub = bob;
@@ -822,3 +930,53 @@
expect(symbol).to.equal('CHANGE');
});
});
+
+describe('Negative tests', () => {
+ let donor: IKeyringPair;
+ let minter: IKeyringPair;
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
+ before(async function() {
+ await usingEthPlaygrounds(async (helper, privateKey) => {
+ donor = await privateKey({filename: __filename});
+ [minter, alice, bob] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+ });
+ });
+
+ itEth('[negative] Cant perform burn without approval', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+
+ const owner = bob;
+ const spender = await helper.eth.createAccountWithBalance(donor, 100n);
+
+ const token = await collection.mintToken(minter, {Substrate: owner.address});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'nft');
+
+ {
+ const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);
+ await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;
+ }
+ });
+
+ itEth('[negative] Cant perform transfer without approval', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+ const owner = bob;
+ const receiver = alice;
+
+ const spender = await helper.eth.createAccountWithBalance(donor, 100n);
+
+ const token = await collection.mintToken(minter, {Substrate: owner.address});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'nft');
+
+ {
+ const ownerCross = helper.ethCrossAccount.fromKeyringPair(owner);
+ const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);
+ await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;
+ }
+ });
+});
tests/src/eth/reFungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/reFungible.test.ts
+++ b/tests/src/eth/reFungible.test.ts
@@ -169,6 +169,136 @@
}
});
+ itEth('Can perform setApprovalForAll()', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const operator = helper.eth.createAccount();
+
+ const collection = await helper.rft.mintCollection(minter, {});
+
+ const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
+
+ const approvedBefore = await contract.methods.isApprovedForAll(owner, operator).call();
+ expect(approvedBefore).to.be.equal(false);
+
+ {
+ const result = await contract.methods.setApprovalForAll(operator, true).send({from: owner});
+
+ expect(result.events.ApprovalForAll).to.be.like({
+ address: collectionAddress,
+ event: 'ApprovalForAll',
+ returnValues: {
+ owner,
+ operator,
+ approved: true,
+ },
+ });
+
+ const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();
+ expect(approvedAfter).to.be.equal(true);
+ }
+
+ {
+ const result = await contract.methods.setApprovalForAll(operator, false).send({from: owner});
+
+ expect(result.events.ApprovalForAll).to.be.like({
+ address: collectionAddress,
+ event: 'ApprovalForAll',
+ returnValues: {
+ owner,
+ operator,
+ approved: false,
+ },
+ });
+
+ const approvedAfter = await contract.methods.isApprovedForAll(owner, operator).call();
+ expect(approvedAfter).to.be.equal(false);
+ }
+ });
+
+ itEth('Can perform burn with ApprovalForAll', async ({helper}) => {
+ const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const operator = await helper.eth.createAccountWithBalance(donor, 100n);
+
+ const token = await collection.mintToken(minter, 100n, {Ethereum: owner});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'rft');
+
+ {
+ await contract.methods.setApprovalForAll(operator, true).send({from: owner});
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ const result = await contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: operator});
+ const events = result.events.Transfer;
+
+ expect(events).to.be.like({
+ address,
+ event: 'Transfer',
+ returnValues: {
+ from: owner,
+ to: '0x0000000000000000000000000000000000000000',
+ tokenId: token.tokenId.toString(),
+ },
+ });
+ }
+ });
+
+ itEth('Can perform burn with approve and approvalForAll', async ({helper}) => {
+ const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const operator = await helper.eth.createAccountWithBalance(donor, 100n);
+
+ const token = await collection.mintToken(minter, 100n, {Ethereum: owner});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'rft');
+
+ const rftToken = helper.ethNativeContract.rftTokenById(token.collectionId, token.tokenId, owner);
+
+ {
+ await rftToken.methods.approve(operator, 15n).send({from: owner});
+ await contract.methods.setApprovalForAll(operator, true).send({from: owner});
+ await rftToken.methods.burnFrom(owner, 10n).send({from: operator});
+ const allowance = await rftToken.methods.allowance(owner, operator).call();
+ expect(allowance).to.be.equal('5');
+ }
+ });
+
+ itEth('Can perform transfer with ApprovalForAll', async ({helper}) => {
+ const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+
+ const owner = await helper.eth.createAccountWithBalance(donor);
+ const operator = await helper.eth.createAccountWithBalance(donor);
+ const receiver = charlie;
+
+ const token = await collection.mintToken(minter, 100n, {Ethereum: owner});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'rft');
+
+ {
+ await contract.methods.setApprovalForAll(operator, true).send({from: owner});
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);
+ const result = await contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: operator});
+ const event = result.events.Transfer;
+ expect(event).to.be.like({
+ address: helper.ethAddress.fromCollectionId(collection.collectionId),
+ event: 'Transfer',
+ returnValues: {
+ from: owner,
+ to: helper.address.substrateToEth(receiver.address),
+ tokenId: token.tokenId.toString(),
+ },
+ });
+ }
+
+ expect(await token.getTop10Owners()).to.be.like([{Substrate: receiver.address}]);
+ });
+
itEth('Can perform burn()', async ({helper}) => {
const caller = await helper.eth.createAccountWithBalance(donor);
const {collectionAddress} = await helper.eth.createRFTCollection(caller, 'Burny', '6', '6');
@@ -594,3 +724,52 @@
expect(symbol).to.equal('12');
});
});
+
+describe('Negative tests', () => {
+ let donor: IKeyringPair;
+ let minter: IKeyringPair;
+ let alice: IKeyringPair;
+
+ before(async function() {
+ await usingEthPlaygrounds(async (helper, privateKey) => {
+ donor = await privateKey({filename: __filename});
+ [minter, alice] = await helper.arrange.createAccounts([100n, 100n], donor);
+ });
+ });
+
+ itEth('[negative] Cant perform burn without approval', async ({helper}) => {
+ const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+
+ const owner = await helper.eth.createAccountWithBalance(donor, 100n);
+ const spender = await helper.eth.createAccountWithBalance(donor, 100n);
+
+ const token = await collection.mintToken(minter, 100n, {Ethereum: owner});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'rft');
+
+ {
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ await expect(contract.methods.burnFromCross(ownerCross, token.tokenId).send({from: spender})).to.be.rejected;
+ }
+ });
+
+ itEth('[negative] Cant perform transfer without approval', async ({helper}) => {
+ const collection = await helper.rft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+ const owner = await helper.eth.createAccountWithBalance(donor, 100n);
+ const receiver = alice;
+
+ const spender = await helper.eth.createAccountWithBalance(donor, 100n);
+
+ const token = await collection.mintToken(minter, 100n, {Ethereum: owner});
+
+ const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+ const contract = helper.ethNativeContract.collection(address, 'rft');
+
+ {
+ const ownerCross = helper.ethCrossAccount.fromAddress(owner);
+ const recieverCross = helper.ethCrossAccount.fromKeyringPair(receiver);
+ await expect(contract.methods.transferFromCross(ownerCross, recieverCross, token.tokenId).send({from: spender})).to.be.rejected;
+ }
+ });
+});
tests/src/interfaces/augment-api-errors.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-errors.ts
+++ b/tests/src/interfaces/augment-api-errors.ts
@@ -386,6 +386,10 @@
**/
NotFungibleDataUsedToMintFungibleCollectionToken: AugmentedError<ApiType>;
/**
+ * Setting approval for all is not allowed.
+ **/
+ SettingApprovalForAllNotAllowed: AugmentedError<ApiType>;
+ /**
* Setting item properties is not allowed.
**/
SettingPropertiesNotAllowed: AugmentedError<ApiType>;
tests/src/interfaces/augment-api-events.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-events.ts
+++ b/tests/src/interfaces/augment-api-events.ts
@@ -107,6 +107,10 @@
**/
Approved: AugmentedEvent<ApiType, [u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
/**
+ * Amount pieces of token owned by `sender` was approved for `spender`.
+ **/
+ ApprovedForAll: AugmentedEvent<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;
+ /**
* New collection was created
**/
CollectionCreated: AugmentedEvent<ApiType, [u32, u8, AccountId32]>;
tests/src/interfaces/augment-api-query.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-query.ts
+++ b/tests/src/interfaces/augment-api-query.ts
@@ -442,6 +442,10 @@
**/
tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
/**
+ * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.
+ **/
+ walletOperator: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<Option<bool>>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]>;
+ /**
* Generic query
**/
[key: string]: QueryableStorageEntry<ApiType>;
@@ -645,6 +649,10 @@
**/
totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
/**
+ * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.
+ **/
+ walletOperator: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<Option<bool>>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]>;
+ /**
* Generic query
**/
[key: string]: QueryableStorageEntry<ApiType>;
tests/src/interfaces/augment-api-rpc.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-rpc.ts
+++ b/tests/src/interfaces/augment-api-rpc.ts
@@ -720,6 +720,10 @@
**/
effectiveCollectionLimits: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<UpDataStructsCollectionLimits>>>;
/**
+ * Tells whether an operator is approved by a given owner.
+ **/
+ isApprovedForAll: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, owner: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<bool>>>;
+ /**
* Get the last token ID created in a collection
**/
lastTokenId: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u32>>;
tests/src/interfaces/augment-api-tx.tsdiffbeforeafterboth--- a/tests/src/interfaces/augment-api-tx.ts
+++ b/tests/src/interfaces/augment-api-tx.ts
@@ -1545,6 +1545,18 @@
**/
repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;
/**
+ * Sets or unsets the approval of a given operator.
+ *
+ * An operator is allowed to transfer all tokens of the sender on their behalf.
+ *
+ * # Arguments
+ *
+ * * `owner`: Token owner
+ * * `operator`: Operator
+ * * `approve`: Is operator enabled or disabled
+ **/
+ setApprovalForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;
+ /**
* Set specific limits of a collection. Empty, or None fields mean chain default.
*
* # Permissions
tests/src/interfaces/default/types.tsdiffbeforeafterboth--- a/tests/src/interfaces/default/types.ts
+++ b/tests/src/interfaces/default/types.ts
@@ -1286,6 +1286,8 @@
readonly asTransfer: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
readonly isApproved: boolean;
readonly asApproved: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
+ readonly isApprovedForAll: boolean;
+ readonly asApprovedForAll: ITuple<[u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;
readonly isCollectionPropertySet: boolean;
readonly asCollectionPropertySet: ITuple<[u32, Bytes]>;
readonly isCollectionPropertyDeleted: boolean;
@@ -1296,7 +1298,7 @@
readonly asTokenPropertyDeleted: ITuple<[u32, u32, Bytes]>;
readonly isPropertyPermissionSet: boolean;
readonly asPropertyPermissionSet: ITuple<[u32, Bytes]>;
- readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet';
+ readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'ApprovedForAll' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet';
}
/** @name PalletConfigurationCall */
@@ -1603,7 +1605,8 @@
readonly isFungibleItemsDontHaveData: boolean;
readonly isFungibleDisallowsNesting: boolean;
readonly isSettingPropertiesNotAllowed: boolean;
- readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
+ readonly isSettingApprovalForAllNotAllowed: boolean;
+ readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed' | 'SettingApprovalForAllNotAllowed';
}
/** @name PalletInflationCall */
@@ -2309,7 +2312,13 @@
readonly tokenId: u32;
readonly amount: u128;
} & Struct;
- readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition';
+ readonly isSetApprovalForAll: boolean;
+ readonly asSetApprovalForAll: {
+ readonly collectionId: u32;
+ readonly operator: PalletEvmAccountBasicCrossAccountIdRepr;
+ readonly approve: bool;
+ } & Struct;
+ readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition' | 'SetApprovalForAll';
}
/** @name PalletUniqueError */
tests/src/interfaces/lookup.tsdiffbeforeafterboth--- a/tests/src/interfaces/lookup.ts
+++ b/tests/src/interfaces/lookup.ts
@@ -1046,6 +1046,7 @@
ItemDestroyed: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
Transfer: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
Approved: '(u32,u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,u128)',
+ ApprovedForAll: '(u32,PalletEvmAccountBasicCrossAccountIdRepr,PalletEvmAccountBasicCrossAccountIdRepr,bool)',
CollectionPropertySet: '(u32,Bytes)',
CollectionPropertyDeleted: '(u32,Bytes)',
TokenPropertySet: '(u32,u32,Bytes)',
@@ -1054,7 +1055,7 @@
}
},
/**
- * Lookup99: pallet_structure::pallet::Event<T>
+ * Lookup100: pallet_structure::pallet::Event<T>
**/
PalletStructureEvent: {
_enum: {
@@ -1062,7 +1063,7 @@
}
},
/**
- * Lookup100: pallet_rmrk_core::pallet::Event<T>
+ * Lookup101: pallet_rmrk_core::pallet::Event<T>
**/
PalletRmrkCoreEvent: {
_enum: {
@@ -1139,7 +1140,7 @@
}
},
/**
- * Lookup101: rmrk_traits::nft::AccountIdOrCollectionNftTuple<sp_core::crypto::AccountId32>
+ * Lookup102: rmrk_traits::nft::AccountIdOrCollectionNftTuple<sp_core::crypto::AccountId32>
**/
RmrkTraitsNftAccountIdOrCollectionNftTuple: {
_enum: {
@@ -2302,7 +2303,12 @@
repartition: {
collectionId: 'u32',
tokenId: 'u32',
- amount: 'u128'
+ amount: 'u128',
+ },
+ set_approval_for_all: {
+ collectionId: 'u32',
+ operator: 'PalletEvmAccountBasicCrossAccountIdRepr',
+ approve: 'bool'
}
}
},
@@ -3445,7 +3451,7 @@
* Lookup430: pallet_fungible::pallet::Error<T>
**/
PalletFungibleError: {
- _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
+ _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed', 'SettingApprovalForAllNotAllowed']
},
/**
* Lookup431: pallet_refungible::ItemData
tests/src/interfaces/types-lookup.tsdiffbeforeafterboth--- a/tests/src/interfaces/types-lookup.ts
+++ b/tests/src/interfaces/types-lookup.ts
@@ -1182,6 +1182,8 @@
readonly asTransfer: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
readonly isApproved: boolean;
readonly asApproved: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
+ readonly isApprovedForAll: boolean;
+ readonly asApprovedForAll: ITuple<[u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;
readonly isCollectionPropertySet: boolean;
readonly asCollectionPropertySet: ITuple<[u32, Bytes]>;
readonly isCollectionPropertyDeleted: boolean;
@@ -1192,17 +1194,17 @@
readonly asTokenPropertyDeleted: ITuple<[u32, u32, Bytes]>;
readonly isPropertyPermissionSet: boolean;
readonly asPropertyPermissionSet: ITuple<[u32, Bytes]>;
- readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet';
+ readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'ApprovedForAll' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet';
}
- /** @name PalletStructureEvent (99) */
+ /** @name PalletStructureEvent (100) */
interface PalletStructureEvent extends Enum {
readonly isExecuted: boolean;
readonly asExecuted: Result<Null, SpRuntimeDispatchError>;
readonly type: 'Executed';
}
- /** @name PalletRmrkCoreEvent (100) */
+ /** @name PalletRmrkCoreEvent (101) */
interface PalletRmrkCoreEvent extends Enum {
readonly isCollectionCreated: boolean;
readonly asCollectionCreated: {
@@ -1292,7 +1294,7 @@
readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'IssuerChanged' | 'CollectionLocked' | 'NftMinted' | 'NftBurned' | 'NftSent' | 'NftAccepted' | 'NftRejected' | 'PropertySet' | 'ResourceAdded' | 'ResourceRemoval' | 'ResourceAccepted' | 'ResourceRemovalAccepted' | 'PrioritySet';
}
- /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (101) */
+ /** @name RmrkTraitsNftAccountIdOrCollectionNftTuple (102) */
interface RmrkTraitsNftAccountIdOrCollectionNftTuple extends Enum {
readonly isAccountId: boolean;
readonly asAccountId: AccountId32;
@@ -2539,7 +2541,13 @@
readonly tokenId: u32;
readonly amount: u128;
} & Struct;
- readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition';
+ readonly isSetApprovalForAll: boolean;
+ readonly asSetApprovalForAll: {
+ readonly collectionId: u32;
+ readonly operator: PalletEvmAccountBasicCrossAccountIdRepr;
+ readonly approve: bool;
+ } & Struct;
+ readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition' | 'SetApprovalForAll';
}
/** @name UpDataStructsCollectionMode (240) */
@@ -3655,7 +3663,8 @@
readonly isFungibleItemsDontHaveData: boolean;
readonly isFungibleDisallowsNesting: boolean;
readonly isSettingPropertiesNotAllowed: boolean;
- readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
+ readonly isSettingApprovalForAllNotAllowed: boolean;
+ readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed' | 'SettingApprovalForAllNotAllowed';
}
/** @name PalletRefungibleItemData (431) */
tests/src/interfaces/unique/definitions.tsdiffbeforeafterboth--- a/tests/src/interfaces/unique/definitions.ts
+++ b/tests/src/interfaces/unique/definitions.ts
@@ -175,5 +175,10 @@
[collectionParam, tokenParam],
'Option<u128>',
),
+ isApprovedForAll: fun(
+ 'Tells whether an operator is approved by a given owner.',
+ [collectionParam, crossAccountParam('owner'), crossAccountParam('operator')],
+ 'Option<bool>',
+ ),
},
};
tests/src/util/playgrounds/unique.tsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// SPDX-License-Identifier: Apache-2.034/* eslint-disable @typescript-eslint/no-var-requires */5/* eslint-disable function-call-argument-newline */6/* eslint-disable no-prototype-builtins */78import {ApiPromise, WsProvider, Keyring} from '@polkadot/api';9import {ApiInterfaceEvents, SignerOptions} from '@polkadot/api/types';10import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm, base58Encode, blake2AsU8a} from '@polkadot/util-crypto';11import {IKeyringPair} from '@polkadot/types/types';12import {hexToU8a} from '@polkadot/util/hex';13import {u8aConcat} from '@polkadot/util/u8a';14import {15 IApiListeners,16 IBlock,17 IEvent,18 IChainProperties,19 ICollectionCreationOptions,20 ICollectionLimits,21 ICollectionPermissions,22 ICrossAccountId,23 ICrossAccountIdLower,24 ILogger,25 INestingPermissions,26 IProperty,27 IStakingInfo,28 ISchedulerOptions,29 ISubstrateBalance,30 IToken,31 ITokenPropertyPermission,32 ITransactionResult,33 IUniqueHelperLog,34 TApiAllowedListeners,35 TEthereumAccount,36 TSigner,37 TSubstrateAccount,38 TNetworks,39 IForeignAssetMetadata,40 AcalaAssetMetadata,41 MoonbeamAssetInfo,42 DemocracyStandardAccountVote,43 IEthCrossAccountId,44} from './types';45import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';4647export class CrossAccountId implements ICrossAccountId {48 Substrate?: TSubstrateAccount;49 Ethereum?: TEthereumAccount;5051 constructor(account: ICrossAccountId) {52 if (account.Substrate) this.Substrate = account.Substrate;53 if (account.Ethereum) this.Ethereum = account.Ethereum;54 }5556 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {57 switch (domain) {58 case 'Substrate': return new CrossAccountId({Substrate: account.address});59 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();60 }61 }6263 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {64 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});65 }6667 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {68 return encodeAddress(decodeAddress(address), ss58Format);69 }7071 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {72 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});73 }7475 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {76 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);77 return this;78 }7980 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {81 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));82 }8384 toEthereum(): CrossAccountId {85 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});86 return this;87 }8889 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {90 return evmToAddress(address, ss58Format);91 }9293 toSubstrate(ss58Format?: number): CrossAccountId {94 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});95 return this;96 }9798 toLowerCase(): CrossAccountId {99 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();100 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();101 return this;102 }103}104105const nesting = {106 toChecksumAddress(address: string): string {107 if (typeof address === 'undefined') return '';108109 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);110111 address = address.toLowerCase().replace(/^0x/i,'');112 const addressHash = keccakAsHex(address).replace(/^0x/i,'');113 const checksumAddress = ['0x'];114115 for (let i = 0; i < address.length; i++) {116 // If ith character is 8 to f then make it uppercase117 if (parseInt(addressHash[i], 16) > 7) {118 checksumAddress.push(address[i].toUpperCase());119 } else {120 checksumAddress.push(address[i]);121 }122 }123 return checksumAddress.join('');124 },125 tokenIdToAddress(collectionId: number, tokenId: number) {126 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8,'0')}${tokenId.toString(16).padStart(8,'0')}`);127 },128};129130class UniqueUtil {131 static transactionStatus = {132 NOT_READY: 'NotReady',133 FAIL: 'Fail',134 SUCCESS: 'Success',135 };136137 static chainLogType = {138 EXTRINSIC: 'extrinsic',139 RPC: 'rpc',140 };141142 static getTokenAccount(token: IToken): CrossAccountId {143 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});144 }145146 static getTokenAddress(token: IToken): string {147 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);148 }149150 static getDefaultLogger(): ILogger {151 return {152 log(msg: any, level = 'INFO') {153 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));154 },155 level: {156 ERROR: 'ERROR',157 WARNING: 'WARNING',158 INFO: 'INFO',159 },160 };161 }162163 static vec2str(arr: string[] | number[]) {164 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');165 }166167 static str2vec(string: string) {168 if (typeof string !== 'string') return string;169 return Array.from(string).map(x => x.charCodeAt(0));170 }171172 static fromSeed(seed: string, ss58Format = 42) {173 const keyring = new Keyring({type: 'sr25519', ss58Format});174 return keyring.addFromUri(seed);175 }176177 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {178 if (creationResult.status !== this.transactionStatus.SUCCESS) {179 throw Error('Unable to create collection!');180 }181182 let collectionId = null;183 creationResult.result.events.forEach(({event: {data, method, section}}) => {184 if ((section === 'common') && (method === 'CollectionCreated')) {185 collectionId = parseInt(data[0].toString(), 10);186 }187 });188189 if (collectionId === null) {190 throw Error('No CollectionCreated event was found!');191 }192193 return collectionId;194 }195196 static extractTokensFromCreationResult(creationResult: ITransactionResult): {197 success: boolean,198 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],199 } {200 if (creationResult.status !== this.transactionStatus.SUCCESS) {201 throw Error('Unable to create tokens!');202 }203 let success = false;204 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];205 creationResult.result.events.forEach(({event: {data, method, section}}) => {206 if (method === 'ExtrinsicSuccess') {207 success = true;208 } else if ((section === 'common') && (method === 'ItemCreated')) {209 tokens.push({210 collectionId: parseInt(data[0].toString(), 10),211 tokenId: parseInt(data[1].toString(), 10),212 owner: data[2].toHuman(),213 amount: data[3].toBigInt(),214 });215 }216 });217 return {success, tokens};218 }219220 static extractTokensFromBurnResult(burnResult: ITransactionResult): {221 success: boolean,222 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],223 } {224 if (burnResult.status !== this.transactionStatus.SUCCESS) {225 throw Error('Unable to burn tokens!');226 }227 let success = false;228 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];229 burnResult.result.events.forEach(({event: {data, method, section}}) => {230 if (method === 'ExtrinsicSuccess') {231 success = true;232 } else if ((section === 'common') && (method === 'ItemDestroyed')) {233 tokens.push({234 collectionId: parseInt(data[0].toString(), 10),235 tokenId: parseInt(data[1].toString(), 10),236 owner: data[2].toHuman(),237 amount: data[3].toBigInt(),238 });239 }240 });241 return {success, tokens};242 }243244 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {245 let eventId = null;246 events.forEach(({event: {data, method, section}}) => {247 if ((section === expectedSection) && (method === expectedMethod)) {248 eventId = parseInt(data[0].toString(), 10);249 }250 });251252 if (eventId === null) {253 throw Error(`No ${expectedMethod} event was found!`);254 }255 return eventId === collectionId;256 }257258 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {259 const normalizeAddress = (address: string | ICrossAccountId) => {260 if(typeof address === 'string') return address;261 const obj = {} as any;262 Object.keys(address).forEach(k => {263 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];264 });265 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);266 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();267 return address;268 };269 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;270 events.forEach(({event: {data, method, section}}) => {271 if ((section === 'common') && (method === 'Transfer')) {272 const hData = (data as any).toJSON();273 transfer = {274 collectionId: hData[0],275 tokenId: hData[1],276 from: normalizeAddress(hData[2]),277 to: normalizeAddress(hData[3]),278 amount: BigInt(hData[4]),279 };280 }281 });282 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;283 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);284 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);285 isSuccess = isSuccess && amount === transfer.amount;286 return isSuccess;287 }288289 static bigIntToDecimals(number: bigint, decimals = 18) {290 const numberStr = number.toString();291 const dotPos = numberStr.length - decimals;292293 if (dotPos <= 0) {294 return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;295 } else {296 const intPart = numberStr.substring(0, dotPos);297 const fractPart = numberStr.substring(dotPos);298 return intPart + '.' + fractPart;299 }300 }301}302303class UniqueEventHelper {304 private static extractIndex(index: any): [number, number] | string {305 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];306 return index.toJSON();307 }308309 private static extractSub(data: any, subTypes: any): {[key: string]: any} {310 let obj: any = {};311 let index = 0;312313 if (data.entries) {314 for(const [key, value] of data.entries()) {315 obj[key] = this.extractData(value, subTypes[index]);316 index++;317 }318 } else obj = data.toJSON();319320 return obj;321 }322323 private static extractData(data: any, type: any): any {324 if(!type) return data.toHuman();325 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();326 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();327 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);328 return data.toHuman();329 }330331 public static extractEvents(events: {event: any, phase: any}[]): IEvent[] {332 const parsedEvents: IEvent[] = [];333334 events.forEach((record) => {335 const {event, phase} = record;336 const types = event.typeDef;337338 const eventData: IEvent = {339 section: event.section.toString(),340 method: event.method.toString(),341 index: this.extractIndex(event.index),342 data: [],343 phase: phase.toJSON(),344 };345346 event.data.forEach((val: any, index: number) => {347 eventData.data.push(this.extractData(val, types[index]));348 });349350 parsedEvents.push(eventData);351 });352353 return parsedEvents;354 }355}356357export class ChainHelperBase {358 helperBase: any;359360 transactionStatus = UniqueUtil.transactionStatus;361 chainLogType = UniqueUtil.chainLogType;362 util: typeof UniqueUtil;363 eventHelper: typeof UniqueEventHelper;364 logger: ILogger;365 api: ApiPromise | null;366 forcedNetwork: TNetworks | null;367 network: TNetworks | null;368 chainLog: IUniqueHelperLog[];369 children: ChainHelperBase[];370 address: AddressGroup;371 chain: ChainGroup;372373 constructor(logger?: ILogger, helperBase?: any) {374 this.helperBase = helperBase;375376 this.util = UniqueUtil;377 this.eventHelper = UniqueEventHelper;378 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();379 this.logger = logger;380 this.api = null;381 this.forcedNetwork = null;382 this.network = null;383 this.chainLog = [];384 this.children = [];385 this.address = new AddressGroup(this);386 this.chain = new ChainGroup(this);387 }388389 clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {390 Object.setPrototypeOf(helperCls.prototype, this);391 const newHelper = new helperCls(this.logger, options);392393 newHelper.api = this.api;394 newHelper.network = this.network;395 newHelper.forceNetwork = this.forceNetwork;396397 this.children.push(newHelper);398399 return newHelper;400 }401402 getApi(): ApiPromise {403 if(this.api === null) throw Error('API not initialized');404 return this.api;405 }406407 clearChainLog(): void {408 this.chainLog = [];409 }410411 forceNetwork(value: TNetworks): void {412 this.forcedNetwork = value;413 }414415 async connect(wsEndpoint: string, listeners?: IApiListeners) {416 if (this.api !== null) throw Error('Already connected');417 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);418 this.api = api;419 this.network = network;420 }421422 async disconnect() {423 for (const child of this.children) {424 child.clearApi();425 }426427 if (this.api === null) return;428 await this.api.disconnect();429 this.clearApi();430 }431432 clearApi() {433 this.api = null;434 this.network = null;435 }436437 static async detectNetwork(api: ApiPromise): Promise<TNetworks> {438 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;439 const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];440441 if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;442443 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;444 return 'opal';445 }446447 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {448 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});449 await api.isReady;450451 const network = await this.detectNetwork(api);452453 await api.disconnect();454455 return network;456 }457458 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{459 api: ApiPromise;460 network: TNetworks;461 }> {462 if(typeof network === 'undefined' || network === null) network = 'opal';463 const supportedRPC = {464 opal: {465 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,466 },467 quartz: {468 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,469 },470 unique: {471 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,472 },473 rococo: {},474 westend: {},475 moonbeam: {},476 moonriver: {},477 acala: {},478 karura: {},479 westmint: {},480 };481 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);482 const rpc = supportedRPC[network];483484 // TODO: investigate how to replace rpc in runtime485 // api._rpcCore.addUserInterfaces(rpc);486487 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});488489 await api.isReadyOrError;490491 if (typeof listeners === 'undefined') listeners = {};492 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {493 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;494 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);495 }496497 return {api, network};498 }499500 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {501 const {events, status} = data;502 if (status.isReady) {503 return this.transactionStatus.NOT_READY;504 }505 if (status.isBroadcast) {506 return this.transactionStatus.NOT_READY;507 }508 if (status.isInBlock || status.isFinalized) {509 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');510 if (errors.length > 0) {511 return this.transactionStatus.FAIL;512 }513 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {514 return this.transactionStatus.SUCCESS;515 }516 }517518 return this.transactionStatus.FAIL;519 }520521 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {522 const sign = (callback: any) => {523 if(options !== null) return transaction.signAndSend(sender, options, callback);524 return transaction.signAndSend(sender, callback);525 };526 // eslint-disable-next-line no-async-promise-executor527 return new Promise(async (resolve, reject) => {528 try {529 const unsub = await sign((result: any) => {530 const status = this.getTransactionStatus(result);531532 if (status === this.transactionStatus.SUCCESS) {533 this.logger.log(`${label} successful`);534 unsub();535 resolve({result, status});536 } else if (status === this.transactionStatus.FAIL) {537 let moduleError = null;538539 if (result.hasOwnProperty('dispatchError')) {540 const dispatchError = result['dispatchError'];541542 if (dispatchError) {543 if (dispatchError.isModule) {544 const modErr = dispatchError.asModule;545 const errorMeta = dispatchError.registry.findMetaError(modErr);546547 moduleError = `${errorMeta.section}.${errorMeta.name}`;548 } else {549 moduleError = dispatchError.toHuman();550 }551 } else {552 this.logger.log(result, this.logger.level.ERROR);553 }554 }555556 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);557 unsub();558 reject({status, moduleError, result});559 }560 });561 } catch (e) {562 this.logger.log(e, this.logger.level.ERROR);563 reject(e);564 }565 });566 }567568 async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {569 const api = this.getApi();570 const signingInfo = await api.derive.tx.signingInfo(signer.address);571572 // We need to sign the tx because573 // unsigned transactions does not have an inclusion fee574 tx.sign(signer, {575 blockHash: api.genesisHash,576 genesisHash: api.genesisHash,577 runtimeVersion: api.runtimeVersion,578 nonce: signingInfo.nonce,579 });580581 if (len === null) {582 return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;583 } else {584 return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;585 }586 }587588 constructApiCall(apiCall: string, params: any[]) {589 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);590 let call = this.getApi() as any;591 for(const part of apiCall.slice(4).split('.')) {592 call = call[part];593 }594 return call(...params);595 }596597 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {598 if(this.api === null) throw Error('API not initialized');599 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);600601 const startTime = (new Date()).getTime();602 let result: ITransactionResult;603 let events: IEvent[] = [];604 try {605 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;606 events = this.eventHelper.extractEvents(result.result.events);607 }608 catch(e) {609 if(!(e as object).hasOwnProperty('status')) throw e;610 result = e as ITransactionResult;611 }612613 const endTime = (new Date()).getTime();614615 const log = {616 executedAt: endTime,617 executionTime: endTime - startTime,618 type: this.chainLogType.EXTRINSIC,619 status: result.status,620 call: extrinsic,621 signer: this.getSignerAddress(sender),622 params,623 } as IUniqueHelperLog;624625 if(result.status !== this.transactionStatus.SUCCESS) {626 if (result.moduleError) log.moduleError = result.moduleError;627 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;628 }629 if(events.length > 0) log.events = events;630631 this.chainLog.push(log);632633 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {634 if (result.moduleError) throw Error(`${result.moduleError}`);635 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));636 }637 return result;638 }639640 async callRpc(rpc: string, params?: any[]) {641 if(typeof params === 'undefined') params = [];642 if(this.api === null) throw Error('API not initialized');643 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);644645 const startTime = (new Date()).getTime();646 let result;647 let error = null;648 const log = {649 type: this.chainLogType.RPC,650 call: rpc,651 params,652 } as IUniqueHelperLog;653654 try {655 result = await this.constructApiCall(rpc, params);656 }657 catch(e) {658 error = e;659 }660661 const endTime = (new Date()).getTime();662663 log.executedAt = endTime;664 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';665 log.executionTime = endTime - startTime;666667 this.chainLog.push(log);668669 if(error !== null) throw error;670671 return result;672 }673674 getSignerAddress(signer: IKeyringPair | string): string {675 if(typeof signer === 'string') return signer;676 return signer.address;677 }678679 fetchAllPalletNames(): string[] {680 if(this.api === null) throw Error('API not initialized');681 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());682 }683684 fetchMissingPalletNames(requiredPallets: string[]): string[] {685 const palletNames = this.fetchAllPalletNames();686 return requiredPallets.filter(p => !palletNames.includes(p));687 }688}689690691class HelperGroup<T extends ChainHelperBase> {692 helper: T;693694 constructor(uniqueHelper: T) {695 this.helper = uniqueHelper;696 }697}698699700class CollectionGroup extends HelperGroup<UniqueHelper> {701 /**702 * Get number of blocks when sponsored transaction is available.703 *704 * @param collectionId ID of collection705 * @param tokenId ID of token706 * @param addressObj address for which the sponsorship is checked707 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});708 * @returns number of blocks or null if sponsorship hasn't been set709 */710 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {711 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();712 }713714 /**715 * Get the number of created collections.716 *717 * @returns number of created collections718 */719 async getTotalCount(): Promise<number> {720 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();721 }722723 /**724 * Get information about the collection with additional data,725 * including the number of tokens it contains, its administrators,726 * the normalized address of the collection's owner, and decoded name and description.727 *728 * @param collectionId ID of collection729 * @example await getData(2)730 * @returns collection information object731 */732 async getData(collectionId: number): Promise<{733 id: number;734 name: string;735 description: string;736 tokensCount: number;737 admins: CrossAccountId[];738 normalizedOwner: TSubstrateAccount;739 raw: any740 } | null> {741 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);742 const humanCollection = collection.toHuman(), collectionData = {743 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],744 raw: humanCollection,745 } as any, jsonCollection = collection.toJSON();746 if (humanCollection === null) return null;747 collectionData.raw.limits = jsonCollection.limits;748 collectionData.raw.permissions = jsonCollection.permissions;749 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);750 for (const key of ['name', 'description']) {751 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);752 }753754 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))755 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)756 : 0;757 collectionData.admins = await this.getAdmins(collectionId);758759 return collectionData;760 }761762 /**763 * Get the addresses of the collection's administrators, optionally normalized.764 *765 * @param collectionId ID of collection766 * @param normalize whether to normalize the addresses to the default ss58 format767 * @example await getAdmins(1)768 * @returns array of administrators769 */770 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {771 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();772773 return normalize774 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())775 : admins;776 }777778 /**779 * Get the addresses added to the collection allow-list, optionally normalized.780 * @param collectionId ID of collection781 * @param normalize whether to normalize the addresses to the default ss58 format782 * @example await getAllowList(1)783 * @returns array of allow-listed addresses784 */785 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {786 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();787 return normalize788 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())789 : allowListed;790 }791792 /**793 * Get the effective limits of the collection instead of null for default values794 *795 * @param collectionId ID of collection796 * @example await getEffectiveLimits(2)797 * @returns object of collection limits798 */799 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {800 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();801 }802803 /**804 * Burns the collection if the signer has sufficient permissions and collection is empty.805 *806 * @param signer keyring of signer807 * @param collectionId ID of collection808 * @example await helper.collection.burn(aliceKeyring, 3);809 * @returns ```true``` if extrinsic success, otherwise ```false```810 */811 async burn(signer: TSigner, collectionId: number): Promise<boolean> {812 const result = await this.helper.executeExtrinsic(813 signer,814 'api.tx.unique.destroyCollection', [collectionId],815 true,816 );817818 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');819 }820821 /**822 * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.823 *824 * @param signer keyring of signer825 * @param collectionId ID of collection826 * @param sponsorAddress Sponsor substrate address827 * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")828 * @returns ```true``` if extrinsic success, otherwise ```false```829 */830 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {831 const result = await this.helper.executeExtrinsic(832 signer,833 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],834 true,835 );836837 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorSet');838 }839840 /**841 * Confirms consent to sponsor the collection on behalf of the signer.842 *843 * @param signer keyring of signer844 * @param collectionId ID of collection845 * @example confirmSponsorship(aliceKeyring, 10)846 * @returns ```true``` if extrinsic success, otherwise ```false```847 */848 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {849 const result = await this.helper.executeExtrinsic(850 signer,851 'api.tx.unique.confirmSponsorship', [collectionId],852 true,853 );854855 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'SponsorshipConfirmed');856 }857858 /**859 * Removes the sponsor of a collection, regardless if it consented or not.860 *861 * @param signer keyring of signer862 * @param collectionId ID of collection863 * @example removeSponsor(aliceKeyring, 10)864 * @returns ```true``` if extrinsic success, otherwise ```false```865 */866 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {867 const result = await this.helper.executeExtrinsic(868 signer,869 'api.tx.unique.removeCollectionSponsor', [collectionId],870 true,871 );872873 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorRemoved');874 }875876 /**877 * Sets the limits of the collection. At least one limit must be specified for a correct call.878 *879 * @param signer keyring of signer880 * @param collectionId ID of collection881 * @param limits collection limits object882 * @example883 * await setLimits(884 * aliceKeyring,885 * 10,886 * {887 * sponsorTransferTimeout: 0,888 * ownerCanDestroy: false889 * }890 * )891 * @returns ```true``` if extrinsic success, otherwise ```false```892 */893 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {894 const result = await this.helper.executeExtrinsic(895 signer,896 'api.tx.unique.setCollectionLimits', [collectionId, limits],897 true,898 );899900 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionLimitSet');901 }902903 /**904 * Changes the owner of the collection to the new Substrate address.905 *906 * @param signer keyring of signer907 * @param collectionId ID of collection908 * @param ownerAddress substrate address of new owner909 * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")910 * @returns ```true``` if extrinsic success, otherwise ```false```911 */912 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {913 const result = await this.helper.executeExtrinsic(914 signer,915 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],916 true,917 );918919 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionOwnedChanged');920 }921922 /**923 * Adds a collection administrator.924 *925 * @param signer keyring of signer926 * @param collectionId ID of collection927 * @param adminAddressObj Administrator address (substrate or ethereum)928 * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})929 * @returns ```true``` if extrinsic success, otherwise ```false```930 */931 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {932 const result = await this.helper.executeExtrinsic(933 signer,934 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],935 true,936 );937938 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminAdded');939 }940941 /**942 * Removes a collection administrator.943 *944 * @param signer keyring of signer945 * @param collectionId ID of collection946 * @param adminAddressObj Administrator address (substrate or ethereum)947 * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})948 * @returns ```true``` if extrinsic success, otherwise ```false```949 */950 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {951 const result = await this.helper.executeExtrinsic(952 signer,953 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],954 true,955 );956957 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminRemoved');958 }959960 /**961 * Check if user is in allow list.962 *963 * @param collectionId ID of collection964 * @param user Account to check965 * @example await getAdmins(1)966 * @returns is user in allow list967 */968 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {969 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();970 }971972 /**973 * Adds an address to allow list974 * @param signer keyring of signer975 * @param collectionId ID of collection976 * @param addressObj address to add to the allow list977 * @returns ```true``` if extrinsic success, otherwise ```false```978 */979 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {980 const result = await this.helper.executeExtrinsic(981 signer,982 'api.tx.unique.addToAllowList', [collectionId, addressObj],983 true,984 );985986 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressAdded');987 }988989 /**990 * Removes an address from allow list991 *992 * @param signer keyring of signer993 * @param collectionId ID of collection994 * @param addressObj address to remove from the allow list995 * @returns ```true``` if extrinsic success, otherwise ```false```996 */997 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {998 const result = await this.helper.executeExtrinsic(999 signer,1000 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],1001 true,1002 );10031004 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressRemoved');1005 }10061007 /**1008 * Sets onchain permissions for selected collection.1009 *1010 * @param signer keyring of signer1011 * @param collectionId ID of collection1012 * @param permissions collection permissions object1013 * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});1014 * @returns ```true``` if extrinsic success, otherwise ```false```1015 */1016 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {1017 const result = await this.helper.executeExtrinsic(1018 signer,1019 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],1020 true,1021 );10221023 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionPermissionSet');1024 }10251026 /**1027 * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.1028 *1029 * @param signer keyring of signer1030 * @param collectionId ID of collection1031 * @param permissions nesting permissions object1032 * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});1033 * @returns ```true``` if extrinsic success, otherwise ```false```1034 */1035 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1036 return await this.setPermissions(signer, collectionId, {nesting: permissions});1037 }10381039 /**1040 * Disables nesting for selected collection.1041 *1042 * @param signer keyring of signer1043 * @param collectionId ID of collection1044 * @example disableNesting(aliceKeyring, 10);1045 * @returns ```true``` if extrinsic success, otherwise ```false```1046 */1047 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1048 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1049 }10501051 /**1052 * Sets onchain properties to the collection.1053 *1054 * @param signer keyring of signer1055 * @param collectionId ID of collection1056 * @param properties array of property objects1057 * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);1058 * @returns ```true``` if extrinsic success, otherwise ```false```1059 */1060 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1061 const result = await this.helper.executeExtrinsic(1062 signer,1063 'api.tx.unique.setCollectionProperties', [collectionId, properties],1064 true,1065 );10661067 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1068 }10691070 /**1071 * Get collection properties.1072 *1073 * @param collectionId ID of collection1074 * @param propertyKeys optionally filter the returned properties to only these keys1075 * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1076 * @returns array of key-value pairs1077 */1078 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1079 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1080 }10811082 async getCollectionOptions(collectionId: number) {1083 return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1084 }10851086 /**1087 * Deletes onchain properties from the collection.1088 *1089 * @param signer keyring of signer1090 * @param collectionId ID of collection1091 * @param propertyKeys array of property keys to delete1092 * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1093 * @returns ```true``` if extrinsic success, otherwise ```false```1094 */1095 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1096 const result = await this.helper.executeExtrinsic(1097 signer,1098 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1099 true,1100 );11011102 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1103 }11041105 /**1106 * Changes the owner of the token.1107 *1108 * @param signer keyring of signer1109 * @param collectionId ID of collection1110 * @param tokenId ID of token1111 * @param addressObj address of a new owner1112 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1113 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1114 * @returns true if the token success, otherwise false1115 */1116 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1117 const result = await this.helper.executeExtrinsic(1118 signer,1119 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1120 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1121 );11221123 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1124 }11251126 /**1127 *1128 * Change ownership of a token(s) on behalf of the owner.1129 *1130 * @param signer keyring of signer1131 * @param collectionId ID of collection1132 * @param tokenId ID of token1133 * @param fromAddressObj address on behalf of which the token will be sent1134 * @param toAddressObj new token owner1135 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1136 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1137 * @returns true if the token success, otherwise false1138 */1139 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1140 const result = await this.helper.executeExtrinsic(1141 signer,1142 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1143 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1144 );1145 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1146 }11471148 /**1149 *1150 * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1151 *1152 * @param signer keyring of signer1153 * @param collectionId ID of collection1154 * @param tokenId ID of token1155 * @param amount amount of tokens to be burned. For NFT must be set to 1n1156 * @example burnToken(aliceKeyring, 10, 5);1157 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1158 */1159 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1160 const burnResult = await this.helper.executeExtrinsic(1161 signer,1162 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1163 true, // `Unable to burn token for ${label}`,1164 );1165 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1166 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1167 return burnedTokens.success;1168 }11691170 /**1171 * Destroys a concrete instance of NFT on behalf of the owner1172 *1173 * @param signer keyring of signer1174 * @param collectionId ID of collection1175 * @param tokenId ID of token1176 * @param fromAddressObj address on behalf of which the token will be burnt1177 * @param amount amount of tokens to be burned. For NFT must be set to 1n1178 * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1179 * @returns ```true``` if extrinsic success, otherwise ```false```1180 */1181 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1182 const burnResult = await this.helper.executeExtrinsic(1183 signer,1184 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1185 true, // `Unable to burn token from for ${label}`,1186 );1187 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1188 return burnedTokens.success && burnedTokens.tokens.length > 0;1189 }11901191 /**1192 * Set, change, or remove approved address to transfer the ownership of the NFT.1193 *1194 * @param signer keyring of signer1195 * @param collectionId ID of collection1196 * @param tokenId ID of token1197 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1198 * @param amount amount of token to be approved. For NFT must be set to 1n1199 * @returns ```true``` if extrinsic success, otherwise ```false```1200 */1201 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1202 const approveResult = await this.helper.executeExtrinsic(1203 signer,1204 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1205 true, // `Unable to approve token for ${label}`,1206 );12071208 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1209 }12101211 /**1212 * Get the amount of token pieces approved to transfer or burn. Normally 0.1213 *1214 * @param collectionId ID of collection1215 * @param tokenId ID of token1216 * @param toAccountObj address which is approved to use token pieces1217 * @param fromAccountObj address which may have allowed the use of its owned tokens1218 * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1219 * @returns number of approved to transfer pieces1220 */1221 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1222 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1223 }12241225 /**1226 * Get the last created token ID in a collection1227 *1228 * @param collectionId ID of collection1229 * @example getLastTokenId(10);1230 * @returns id of the last created token1231 */1232 async getLastTokenId(collectionId: number): Promise<number> {1233 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1234 }12351236 /**1237 * Check if token exists1238 *1239 * @param collectionId ID of collection1240 * @param tokenId ID of token1241 * @example doesTokenExist(10, 20);1242 * @returns true if the token exists, otherwise false1243 */1244 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1245 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1246 }1247}12481249class NFTnRFT extends CollectionGroup {1250 /**1251 * Get tokens owned by account1252 *1253 * @param collectionId ID of collection1254 * @param addressObj tokens owner1255 * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1256 * @returns array of token ids owned by account1257 */1258 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1259 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1260 }12611262 /**1263 * Get token data1264 *1265 * @param collectionId ID of collection1266 * @param tokenId ID of token1267 * @param propertyKeys optionally filter the token properties to only these keys1268 * @param blockHashAt optionally query the data at some block with this hash1269 * @example getToken(10, 5);1270 * @returns human readable token data1271 */1272 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1273 properties: IProperty[];1274 owner: CrossAccountId;1275 normalizedOwner: CrossAccountId;1276 }| null> {1277 let tokenData;1278 if(typeof blockHashAt === 'undefined') {1279 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1280 }1281 else {1282 if(propertyKeys.length == 0) {1283 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1284 if(!collection) return null;1285 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1286 }1287 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1288 }1289 tokenData = tokenData.toHuman();1290 if (tokenData === null || tokenData.owner === null) return null;1291 const owner = {} as any;1292 for (const key of Object.keys(tokenData.owner)) {1293 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'1294 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])1295 : tokenData.owner[key];1296 }1297 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1298 return tokenData;1299 }13001301 /**1302 * Set permissions to change token properties1303 *1304 * @param signer keyring of signer1305 * @param collectionId ID of collection1306 * @param permissions permissions to change a property by the collection admin or token owner1307 * @example setTokenPropertyPermissions(1308 * aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1309 * )1310 * @returns true if extrinsic success otherwise false1311 */1312 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1313 const result = await this.helper.executeExtrinsic(1314 signer,1315 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1316 true,1317 );13181319 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1320 }13211322 /**1323 * Get token property permissions.1324 *1325 * @param collectionId ID of collection1326 * @param propertyKeys optionally filter the returned property permissions to only these keys1327 * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1328 * @returns array of key-permission pairs1329 */1330 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1331 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1332 }13331334 /**1335 * Set token properties1336 *1337 * @param signer keyring of signer1338 * @param collectionId ID of collection1339 * @param tokenId ID of token1340 * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1341 * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1342 * @returns ```true``` if extrinsic success, otherwise ```false```1343 */1344 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1345 const result = await this.helper.executeExtrinsic(1346 signer,1347 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1348 true,1349 );13501351 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1352 }13531354 /**1355 * Get properties, metadata assigned to a token.1356 *1357 * @param collectionId ID of collection1358 * @param tokenId ID of token1359 * @param propertyKeys optionally filter the returned properties to only these keys1360 * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1361 * @returns array of key-value pairs1362 */1363 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1364 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1365 }13661367 /**1368 * Delete the provided properties of a token1369 * @param signer keyring of signer1370 * @param collectionId ID of collection1371 * @param tokenId ID of token1372 * @param propertyKeys property keys to be deleted1373 * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1374 * @returns ```true``` if extrinsic success, otherwise ```false```1375 */1376 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1377 const result = await this.helper.executeExtrinsic(1378 signer,1379 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1380 true,1381 );13821383 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1384 }13851386 /**1387 * Mint new collection1388 *1389 * @param signer keyring of signer1390 * @param collectionOptions basic collection options and properties1391 * @param mode NFT or RFT type of a collection1392 * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1393 * @returns object of the created collection1394 */1395 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1396 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1397 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1398 for (const key of ['name', 'description', 'tokenPrefix']) {1399 if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);1400 }1401 const creationResult = await this.helper.executeExtrinsic(1402 signer,1403 'api.tx.unique.createCollectionEx', [collectionOptions],1404 true, // errorLabel,1405 );1406 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1407 }14081409 getCollectionObject(_collectionId: number): any {1410 return null;1411 }14121413 getTokenObject(_collectionId: number, _tokenId: number): any {1414 return null;1415 }1416}141714181419class NFTGroup extends NFTnRFT {1420 /**1421 * Get collection object1422 * @param collectionId ID of collection1423 * @example getCollectionObject(2);1424 * @returns instance of UniqueNFTCollection1425 */1426 getCollectionObject(collectionId: number): UniqueNFTCollection {1427 return new UniqueNFTCollection(collectionId, this.helper);1428 }14291430 /**1431 * Get token object1432 * @param collectionId ID of collection1433 * @param tokenId ID of token1434 * @example getTokenObject(10, 5);1435 * @returns instance of UniqueNFTToken1436 */1437 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1438 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1439 }14401441 /**1442 * Get token's owner1443 * @param collectionId ID of collection1444 * @param tokenId ID of token1445 * @param blockHashAt optionally query the data at the block with this hash1446 * @example getTokenOwner(10, 5);1447 * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1448 */1449 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1450 let owner;1451 if (typeof blockHashAt === 'undefined') {1452 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1453 } else {1454 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1455 }1456 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1457 }14581459 /**1460 * Is token approved to transfer1461 * @param collectionId ID of collection1462 * @param tokenId ID of token1463 * @param toAccountObj address to be approved1464 * @returns ```true``` if extrinsic success, otherwise ```false```1465 */1466 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1467 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1468 }14691470 /**1471 * Changes the owner of the token.1472 *1473 * @param signer keyring of signer1474 * @param collectionId ID of collection1475 * @param tokenId ID of token1476 * @param addressObj address of a new owner1477 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1478 * @returns ```true``` if extrinsic success, otherwise ```false```1479 */1480 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1481 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1482 }14831484 /**1485 *1486 * Change ownership of a NFT on behalf of the owner.1487 *1488 * @param signer keyring of signer1489 * @param collectionId ID of collection1490 * @param tokenId ID of token1491 * @param fromAddressObj address on behalf of which the token will be sent1492 * @param toAddressObj new token owner1493 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1494 * @returns ```true``` if extrinsic success, otherwise ```false```1495 */1496 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1497 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1498 }14991500 /**1501 * Recursively find the address that owns the token1502 * @param collectionId ID of collection1503 * @param tokenId ID of token1504 * @param blockHashAt1505 * @example getTokenTopmostOwner(10, 5);1506 * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1507 */1508 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1509 let owner;1510 if (typeof blockHashAt === 'undefined') {1511 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1512 } else {1513 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1514 }15151516 if (owner === null) return null;15171518 return owner.toHuman();1519 }15201521 /**1522 * Get tokens nested in the provided token1523 * @param collectionId ID of collection1524 * @param tokenId ID of token1525 * @param blockHashAt optionally query the data at the block with this hash1526 * @example getTokenChildren(10, 5);1527 * @returns tokens whose depth of nesting is <= 51528 */1529 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1530 let children;1531 if(typeof blockHashAt === 'undefined') {1532 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1533 } else {1534 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1535 }15361537 return children.toJSON().map((x: any) => {1538 return {collectionId: x.collection, tokenId: x.token};1539 });1540 }15411542 /**1543 * Nest one token into another1544 * @param signer keyring of signer1545 * @param tokenObj token to be nested1546 * @param rootTokenObj token to be parent1547 * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1548 * @returns ```true``` if extrinsic success, otherwise ```false```1549 */1550 async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1551 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1552 const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1553 if(!result) {1554 throw Error('Unable to nest token!');1555 }1556 return result;1557 }15581559 /**1560 * Remove token from nested state1561 * @param signer keyring of signer1562 * @param tokenObj token to unnest1563 * @param rootTokenObj parent of a token1564 * @param toAddressObj address of a new token owner1565 * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1566 * @returns ```true``` if extrinsic success, otherwise ```false```1567 */1568 async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1569 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1570 const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1571 if(!result) {1572 throw Error('Unable to unnest token!');1573 }1574 return result;1575 }15761577 /**1578 * Mint new collection1579 * @param signer keyring of signer1580 * @param collectionOptions Collection options1581 * @example1582 * mintCollection(aliceKeyring, {1583 * name: 'New',1584 * description: 'New collection',1585 * tokenPrefix: 'NEW',1586 * })1587 * @returns object of the created collection1588 */1589 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1590 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1591 }15921593 /**1594 * Mint new token1595 * @param signer keyring of signer1596 * @param data token data1597 * @returns created token object1598 */1599 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1600 const creationResult = await this.helper.executeExtrinsic(1601 signer,1602 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1603 nft: {1604 properties: data.properties,1605 },1606 }],1607 true,1608 );1609 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1610 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1611 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1612 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1613 }16141615 /**1616 * Mint multiple NFT tokens1617 * @param signer keyring of signer1618 * @param collectionId ID of collection1619 * @param tokens array of tokens with owner and properties1620 * @example1621 * mintMultipleTokens(aliceKeyring, 10, [{1622 * owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1623 * properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1624 * },{1625 * owner: {Ethereum: "0x9F0583DbB855d..."},1626 * properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1627 * }]);1628 * @returns ```true``` if extrinsic success, otherwise ```false```1629 */1630 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1631 const creationResult = await this.helper.executeExtrinsic(1632 signer,1633 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1634 true,1635 );1636 const collection = this.getCollectionObject(collectionId);1637 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1638 }16391640 /**1641 * Mint multiple NFT tokens with one owner1642 * @param signer keyring of signer1643 * @param collectionId ID of collection1644 * @param owner tokens owner1645 * @param tokens array of tokens with owner and properties1646 * @example1647 * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1648 * properties: [{1649 * key: "gender",1650 * value: "female",1651 * },{1652 * key: "age",1653 * value: "33",1654 * }],1655 * }]);1656 * @returns array of newly created tokens1657 */1658 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1659 const rawTokens = [];1660 for (const token of tokens) {1661 const raw = {NFT: {properties: token.properties}};1662 rawTokens.push(raw);1663 }1664 const creationResult = await this.helper.executeExtrinsic(1665 signer,1666 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1667 true,1668 );1669 const collection = this.getCollectionObject(collectionId);1670 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1671 }16721673 /**1674 * Set, change, or remove approved address to transfer the ownership of the NFT.1675 *1676 * @param signer keyring of signer1677 * @param collectionId ID of collection1678 * @param tokenId ID of token1679 * @param toAddressObj address to approve1680 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1681 * @returns ```true``` if extrinsic success, otherwise ```false```1682 */1683 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId) {1684 return super.approveToken(signer, collectionId, tokenId, toAddressObj, 1n);1685 }1686}168716881689class RFTGroup extends NFTnRFT {1690 /**1691 * Get collection object1692 * @param collectionId ID of collection1693 * @example getCollectionObject(2);1694 * @returns instance of UniqueRFTCollection1695 */1696 getCollectionObject(collectionId: number): UniqueRFTCollection {1697 return new UniqueRFTCollection(collectionId, this.helper);1698 }16991700 /**1701 * Get token object1702 * @param collectionId ID of collection1703 * @param tokenId ID of token1704 * @example getTokenObject(10, 5);1705 * @returns instance of UniqueNFTToken1706 */1707 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1708 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1709 }17101711 /**1712 * Get top 10 token owners with the largest number of pieces1713 * @param collectionId ID of collection1714 * @param tokenId ID of token1715 * @example getTokenTop10Owners(10, 5);1716 * @returns array of top 10 owners1717 */1718 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1719 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1720 }17211722 /**1723 * Get number of pieces owned by address1724 * @param collectionId ID of collection1725 * @param tokenId ID of token1726 * @param addressObj address token owner1727 * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1728 * @returns number of pieces ownerd by address1729 */1730 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1731 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1732 }17331734 /**1735 * Transfer pieces of token to another address1736 * @param signer keyring of signer1737 * @param collectionId ID of collection1738 * @param tokenId ID of token1739 * @param addressObj address of a new owner1740 * @param amount number of pieces to be transfered1741 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1742 * @returns ```true``` if extrinsic success, otherwise ```false```1743 */1744 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1745 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1746 }17471748 /**1749 * Change ownership of some pieces of RFT on behalf of the owner.1750 * @param signer keyring of signer1751 * @param collectionId ID of collection1752 * @param tokenId ID of token1753 * @param fromAddressObj address on behalf of which the token will be sent1754 * @param toAddressObj new token owner1755 * @param amount number of pieces to be transfered1756 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1757 * @returns ```true``` if extrinsic success, otherwise ```false```1758 */1759 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1760 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1761 }17621763 /**1764 * Mint new collection1765 * @param signer keyring of signer1766 * @param collectionOptions Collection options1767 * @example1768 * mintCollection(aliceKeyring, {1769 * name: 'New',1770 * description: 'New collection',1771 * tokenPrefix: 'NEW',1772 * })1773 * @returns object of the created collection1774 */1775 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1776 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1777 }17781779 /**1780 * Mint new token1781 * @param signer keyring of signer1782 * @param data token data1783 * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1784 * @returns created token object1785 */1786 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1787 const creationResult = await this.helper.executeExtrinsic(1788 signer,1789 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1790 refungible: {1791 pieces: data.pieces,1792 properties: data.properties,1793 },1794 }],1795 true,1796 );1797 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1798 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1799 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1800 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1801 }18021803 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1804 throw Error('Not implemented');1805 const creationResult = await this.helper.executeExtrinsic(1806 signer,1807 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1808 true, // `Unable to mint RFT tokens for ${label}`,1809 );1810 const collection = this.getCollectionObject(collectionId);1811 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1812 }18131814 /**1815 * Mint multiple RFT tokens with one owner1816 * @param signer keyring of signer1817 * @param collectionId ID of collection1818 * @param owner tokens owner1819 * @param tokens array of tokens with properties and pieces1820 * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1821 * @returns array of newly created RFT tokens1822 */1823 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1824 const rawTokens = [];1825 for (const token of tokens) {1826 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1827 rawTokens.push(raw);1828 }1829 const creationResult = await this.helper.executeExtrinsic(1830 signer,1831 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1832 true,1833 );1834 const collection = this.getCollectionObject(collectionId);1835 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1836 }18371838 /**1839 * Destroys a concrete instance of RFT.1840 * @param signer keyring of signer1841 * @param collectionId ID of collection1842 * @param tokenId ID of token1843 * @param amount number of pieces to be burnt1844 * @example burnToken(aliceKeyring, 10, 5);1845 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1846 */1847 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1848 return await super.burnToken(signer, collectionId, tokenId, amount);1849 }18501851 /**1852 * Destroys a concrete instance of RFT on behalf of the owner.1853 * @param signer keyring of signer1854 * @param collectionId ID of collection1855 * @param tokenId ID of token1856 * @param fromAddressObj address on behalf of which the token will be burnt1857 * @param amount number of pieces to be burnt1858 * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1859 * @returns ```true``` if extrinsic success, otherwise ```false```1860 */1861 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1862 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1863 }18641865 /**1866 * Set, change, or remove approved address to transfer the ownership of the RFT.1867 *1868 * @param signer keyring of signer1869 * @param collectionId ID of collection1870 * @param tokenId ID of token1871 * @param toAddressObj address to approve1872 * @param amount number of pieces to be approved1873 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);1874 * @returns true if the token success, otherwise false1875 */1876 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1877 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1878 }18791880 /**1881 * Get total number of pieces1882 * @param collectionId ID of collection1883 * @param tokenId ID of token1884 * @example getTokenTotalPieces(10, 5);1885 * @returns number of pieces1886 */1887 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {1888 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();1889 }18901891 /**1892 * Change number of token pieces. Signer must be the owner of all token pieces.1893 * @param signer keyring of signer1894 * @param collectionId ID of collection1895 * @param tokenId ID of token1896 * @param amount new number of pieces1897 * @example repartitionToken(aliceKeyring, 10, 5, 12345n);1898 * @returns true if the repartion was success, otherwise false1899 */1900 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {1901 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);1902 const repartitionResult = await this.helper.executeExtrinsic(1903 signer,1904 'api.tx.unique.repartition', [collectionId, tokenId, amount],1905 true,1906 );1907 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');1908 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');1909 }1910}191119121913class FTGroup extends CollectionGroup {1914 /**1915 * Get collection object1916 * @param collectionId ID of collection1917 * @example getCollectionObject(2);1918 * @returns instance of UniqueFTCollection1919 */1920 getCollectionObject(collectionId: number): UniqueFTCollection {1921 return new UniqueFTCollection(collectionId, this.helper);1922 }19231924 /**1925 * Mint new fungible collection1926 * @param signer keyring of signer1927 * @param collectionOptions Collection options1928 * @param decimalPoints number of token decimals1929 * @example1930 * mintCollection(aliceKeyring, {1931 * name: 'New',1932 * description: 'New collection',1933 * tokenPrefix: 'NEW',1934 * }, 18)1935 * @returns newly created fungible collection1936 */1937 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {1938 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1939 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');1940 collectionOptions.mode = {fungible: decimalPoints};1941 for (const key of ['name', 'description', 'tokenPrefix']) {1942 if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);1943 }1944 const creationResult = await this.helper.executeExtrinsic(1945 signer,1946 'api.tx.unique.createCollectionEx', [collectionOptions],1947 true,1948 );1949 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1950 }19511952 /**1953 * Mint tokens1954 * @param signer keyring of signer1955 * @param collectionId ID of collection1956 * @param owner address owner of new tokens1957 * @param amount amount of tokens to be meanted1958 * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);1959 * @returns ```true``` if extrinsic success, otherwise ```false```1960 */1961 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {1962 const creationResult = await this.helper.executeExtrinsic(1963 signer,1964 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {1965 fungible: {1966 value: amount,1967 },1968 }],1969 true, // `Unable to mint fungible tokens for ${label}`,1970 );1971 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1972 }19731974 /**1975 * Mint multiple Fungible tokens with one owner1976 * @param signer keyring of signer1977 * @param collectionId ID of collection1978 * @param owner tokens owner1979 * @param tokens array of tokens with properties and pieces1980 * @returns ```true``` if extrinsic success, otherwise ```false```1981 */1982 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {1983 const rawTokens = [];1984 for (const token of tokens) {1985 const raw = {Fungible: {Value: token.value}};1986 rawTokens.push(raw);1987 }1988 const creationResult = await this.helper.executeExtrinsic(1989 signer,1990 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1991 true,1992 );1993 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1994 }19951996 /**1997 * Get the top 10 owners with the largest balance for the Fungible collection1998 * @param collectionId ID of collection1999 * @example getTop10Owners(10);2000 * @returns array of ```ICrossAccountId```2001 */2002 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {2003 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);2004 }20052006 /**2007 * Get account balance2008 * @param collectionId ID of collection2009 * @param addressObj address of owner2010 * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})2011 * @returns amount of fungible tokens owned by address2012 */2013 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {2014 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();2015 }20162017 /**2018 * Transfer tokens to address2019 * @param signer keyring of signer2020 * @param collectionId ID of collection2021 * @param toAddressObj address recipient2022 * @param amount amount of tokens to be sent2023 * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2024 * @returns ```true``` if extrinsic success, otherwise ```false```2025 */2026 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2027 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);2028 }20292030 /**2031 * Transfer some tokens on behalf of the owner.2032 * @param signer keyring of signer2033 * @param collectionId ID of collection2034 * @param fromAddressObj address on behalf of which tokens will be sent2035 * @param toAddressObj address where token to be sent2036 * @param amount number of tokens to be sent2037 * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);2038 * @returns ```true``` if extrinsic success, otherwise ```false```2039 */2040 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2041 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2042 }20432044 /**2045 * Destroy some amount of tokens2046 * @param signer keyring of signer2047 * @param collectionId ID of collection2048 * @param amount amount of tokens to be destroyed2049 * @example burnTokens(aliceKeyring, 10, 1000n);2050 * @returns ```true``` if extrinsic success, otherwise ```false```2051 */2052 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {2053 return await super.burnToken(signer, collectionId, 0, amount);2054 }20552056 /**2057 * Burn some tokens on behalf of the owner.2058 * @param signer keyring of signer2059 * @param collectionId ID of collection2060 * @param fromAddressObj address on behalf of which tokens will be burnt2061 * @param amount amount of tokens to be burnt2062 * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2063 * @returns ```true``` if extrinsic success, otherwise ```false```2064 */2065 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {2066 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2067 }20682069 /**2070 * Get total collection supply2071 * @param collectionId2072 * @returns2073 */2074 async getTotalPieces(collectionId: number): Promise<bigint> {2075 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2076 }20772078 /**2079 * Set, change, or remove approved address to transfer tokens.2080 *2081 * @param signer keyring of signer2082 * @param collectionId ID of collection2083 * @param toAddressObj address to be approved2084 * @param amount amount of tokens to be approved2085 * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2086 * @returns ```true``` if extrinsic success, otherwise ```false```2087 */2088 approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2089 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2090 }20912092 /**2093 * Get amount of fungible tokens approved to transfer2094 * @param collectionId ID of collection2095 * @param fromAddressObj owner of tokens2096 * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2097 * @returns number of tokens approved for the transfer2098 */2099 getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2100 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2101 }2102}210321042105class ChainGroup extends HelperGroup<ChainHelperBase> {2106 /**2107 * Get system properties of a chain2108 * @example getChainProperties();2109 * @returns ss58Format, token decimals, and token symbol2110 */2111 getChainProperties(): IChainProperties {2112 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2113 return {2114 ss58Format: properties.ss58Format.toJSON(),2115 tokenDecimals: properties.tokenDecimals.toJSON(),2116 tokenSymbol: properties.tokenSymbol.toJSON(),2117 };2118 }21192120 /**2121 * Get chain header2122 * @example getLatestBlockNumber();2123 * @returns the number of the last block2124 */2125 async getLatestBlockNumber(): Promise<number> {2126 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2127 }21282129 /**2130 * Get block hash by block number2131 * @param blockNumber number of block2132 * @example getBlockHashByNumber(12345);2133 * @returns hash of a block2134 */2135 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2136 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2137 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2138 return blockHash;2139 }21402141 // TODO add docs2142 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2143 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2144 if (!blockHash) return null;2145 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2146 }21472148 /**2149 * Get account nonce2150 * @param address substrate address2151 * @example getNonce("5GrwvaEF5zXb26Fz...");2152 * @returns number, account's nonce2153 */2154 async getNonce(address: TSubstrateAccount): Promise<number> {2155 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2156 }2157}21582159class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2160 /**2161 * Get substrate address balance2162 * @param address substrate address2163 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2164 * @returns amount of tokens on address2165 */2166 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2167 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2168 }21692170 /**2171 * Transfer tokens to substrate address2172 * @param signer keyring of signer2173 * @param address substrate address of a recipient2174 * @param amount amount of tokens to be transfered2175 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2176 * @returns ```true``` if extrinsic success, otherwise ```false```2177 */2178 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2179 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true/*, `Unable to transfer balance from ${this.helper.getSignerAddress(signer)} to ${address}`*/);21802181 let transfer = {from: null, to: null, amount: 0n} as any;2182 result.result.events.forEach(({event: {data, method, section}}) => {2183 if ((section === 'balances') && (method === 'Transfer')) {2184 transfer = {2185 from: this.helper.address.normalizeSubstrate(data[0]),2186 to: this.helper.address.normalizeSubstrate(data[1]),2187 amount: BigInt(data[2]),2188 };2189 }2190 });2191 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from2192 && this.helper.address.normalizeSubstrate(address) === transfer.to2193 && BigInt(amount) === transfer.amount;2194 return isSuccess;2195 }21962197 /**2198 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2199 * @param address substrate address2200 * @returns2201 */2202 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2203 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2204 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2205 }2206}22072208class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2209 /**2210 * Get ethereum address balance2211 * @param address ethereum address2212 * @example getEthereum("0x9F0583DbB855d...")2213 * @returns amount of tokens on address2214 */2215 async getEthereum(address: TEthereumAccount): Promise<bigint> {2216 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2217 }22182219 /**2220 * Transfer tokens to address2221 * @param signer keyring of signer2222 * @param address Ethereum address of a recipient2223 * @param amount amount of tokens to be transfered2224 * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2225 * @returns ```true``` if extrinsic success, otherwise ```false```2226 */2227 async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2228 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);22292230 let transfer = {from: null, to: null, amount: 0n} as any;2231 result.result.events.forEach(({event: {data, method, section}}) => {2232 if ((section === 'balances') && (method === 'Transfer')) {2233 transfer = {2234 from: data[0].toString(),2235 to: data[1].toString(),2236 amount: BigInt(data[2]),2237 };2238 }2239 });2240 const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from2241 && address === transfer.to2242 && BigInt(amount) === transfer.amount;2243 return isSuccess;2244 }2245}22462247class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2248 subBalanceGroup: SubstrateBalanceGroup<T>;2249 ethBalanceGroup: EthereumBalanceGroup<T>;22502251 constructor(helper: T) {2252 super(helper);2253 this.subBalanceGroup = new SubstrateBalanceGroup(helper);2254 this.ethBalanceGroup = new EthereumBalanceGroup(helper);2255 }22562257 getCollectionCreationPrice(): bigint {2258 return 2n * this.getOneTokenNominal();2259 }2260 /**2261 * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2262 * @example getOneTokenNominal()2263 * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2264 */2265 getOneTokenNominal(): bigint {2266 const chainProperties = this.helper.chain.getChainProperties();2267 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2268 }22692270 /**2271 * Get substrate address balance2272 * @param address substrate address2273 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2274 * @returns amount of tokens on address2275 */2276 getSubstrate(address: TSubstrateAccount): Promise<bigint> {2277 return this.subBalanceGroup.getSubstrate(address);2278 }22792280 /**2281 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2282 * @param address substrate address2283 * @returns2284 */2285 getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2286 return this.subBalanceGroup.getSubstrateFull(address);2287 }22882289 /**2290 * Get ethereum address balance2291 * @param address ethereum address2292 * @example getEthereum("0x9F0583DbB855d...")2293 * @returns amount of tokens on address2294 */2295 getEthereum(address: TEthereumAccount): Promise<bigint> {2296 return this.ethBalanceGroup.getEthereum(address);2297 }22982299 /**2300 * Transfer tokens to substrate address2301 * @param signer keyring of signer2302 * @param address substrate address of a recipient2303 * @param amount amount of tokens to be transfered2304 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2305 * @returns ```true``` if extrinsic success, otherwise ```false```2306 */2307 transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2308 return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2309 }23102311 async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2312 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);23132314 let transfer = {from: null, to: null, amount: 0n} as any;2315 result.result.events.forEach(({event: {data, method, section}}) => {2316 if ((section === 'balances') && (method === 'Transfer')) {2317 transfer = {2318 from: this.helper.address.normalizeSubstrate(data[0]),2319 to: this.helper.address.normalizeSubstrate(data[1]),2320 amount: BigInt(data[2]),2321 };2322 }2323 });2324 let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2325 isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2326 isSuccess = isSuccess && BigInt(amount) === transfer.amount;2327 return isSuccess;2328 }2329}23302331class AddressGroup extends HelperGroup<ChainHelperBase> {2332 /**2333 * Normalizes the address to the specified ss58 format, by default ```42```.2334 * @param address substrate address2335 * @param ss58Format format for address conversion, by default ```42```2336 * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2337 * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2338 */2339 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2340 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2341 }23422343 /**2344 * Get address in the connected chain format2345 * @param address substrate address2346 * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2347 * @returns address in chain format2348 */2349 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2350 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2351 }23522353 /**2354 * Get substrate mirror of an ethereum address2355 * @param ethAddress ethereum address2356 * @param toChainFormat false for normalized account2357 * @example ethToSubstrate('0x9F0583DbB855d...')2358 * @returns substrate mirror of a provided ethereum address2359 */2360 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2361 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2362 }23632364 /**2365 * Get ethereum mirror of a substrate address2366 * @param subAddress substrate account2367 * @example substrateToEth("5DnSF6RRjwteE3BrC...")2368 * @returns ethereum mirror of a provided substrate address2369 */2370 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2371 return CrossAccountId.translateSubToEth(subAddress);2372 }23732374 /**2375 * Encode key to substrate address2376 * @param key key for encoding address2377 * @param ss58Format prefix for encoding to the address of the corresponding network2378 * @returns encoded substrate address2379 */2380 encodeSubstrateAddress (key: Uint8Array | string | bigint, ss58Format = 42): string {2381 const u8a :Uint8Array = typeof key === 'string'2382 ? hexToU8a(key)2383 : typeof key === 'bigint'2384 ? hexToU8a(key.toString(16))2385 : key;2386 2387 if (ss58Format < 0 || ss58Format > 16383 || [46, 47].includes(ss58Format)) {2388 throw new Error(`ss58Format is not valid, received ${typeofss58Format} "${ss58Format}"`);2389 }2390 2391 const allowedDecodedLengths = [1, 2, 4, 8, 32, 33];2392 if (!allowedDecodedLengths.includes(u8a.length)) {2393 throw new Error(`key length is not valid, received ${u8a.length}, valid values are ${allowedDecodedLengths.join(', ')}`);2394 }2395 2396 const u8aPrefix = ss58Format < 642397 ? new Uint8Array([ss58Format])2398 : new Uint8Array([2399 ((ss58Format & 0xfc) >> 2) | 0x40,2400 (ss58Format >> 8) | ((ss58Format & 0x03) << 6),2401 ]);24022403 const input = u8aConcat(u8aPrefix, u8a);2404 2405 return base58Encode(u8aConcat(2406 input,2407 blake2AsU8a(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1),2408 ));2409 }24102411 /**2412 * Restore substrate address from bigint representation2413 * @param number decimal representation of substrate address2414 * @returns substrate address2415 */2416 restoreCrossAccountFromBigInt(number: bigint): TSubstrateAccount {2417 if (this.helper.api === null) {2418 throw 'Not connected';2419 }2420 const res = this.helper.api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();2421 if (res === undefined || res === null) {2422 throw 'Restore address error';2423 }2424 return res.toString();2425 }24262427 /**2428 * Convert etherium cross account id to substrate cross account id2429 * @param ethCrossAccount etherium cross account2430 * @returns substrate cross account id2431 */2432 convertCrossAccountFromEthCrossAccount(ethCrossAccount: IEthCrossAccountId): ICrossAccountId {2433 if (ethCrossAccount.sub === '0') {2434 return {Ethereum: ethCrossAccount.eth.toLocaleLowerCase()};2435 }2436 2437 const ss58 = this.restoreCrossAccountFromBigInt(BigInt(ethCrossAccount.sub));2438 return {Substrate: ss58};2439 }24402441 paraSiblingSovereignAccount(paraid: number) {2442 // We are getting a *sibling* parachain sovereign account,2443 // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c2444 const siblingPrefix = '0x7369626c';24452446 const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2447 const suffix = '000000000000000000000000000000000000000000000000';24482449 return siblingPrefix + encodedParaId + suffix;2450 }2451}24522453class StakingGroup extends HelperGroup<UniqueHelper> {2454 /**2455 * Stake tokens for App Promotion2456 * @param signer keyring of signer2457 * @param amountToStake amount of tokens to stake2458 * @param label extra label for log2459 * @returns2460 */2461 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2462 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2463 const _stakeResult = await this.helper.executeExtrinsic(2464 signer, 'api.tx.appPromotion.stake',2465 [amountToStake], true,2466 );2467 // TODO extract info from stakeResult2468 return true;2469 }24702471 /**2472 * Unstake tokens for App Promotion2473 * @param signer keyring of signer2474 * @param amountToUnstake amount of tokens to unstake2475 * @param label extra label for log2476 * @returns block number where balances will be unlocked2477 */2478 async unstake(signer: TSigner, label?: string): Promise<number> {2479 if(typeof label === 'undefined') label = `${signer.address}`;2480 const _unstakeResult = await this.helper.executeExtrinsic(2481 signer, 'api.tx.appPromotion.unstake',2482 [], true,2483 );2484 // TODO extract block number fron events2485 return 1;2486 }24872488 /**2489 * Get total staked amount for address2490 * @param address substrate or ethereum address2491 * @returns total staked amount2492 */2493 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2494 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2495 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2496 }24972498 /**2499 * Get total staked per block2500 * @param address substrate or ethereum address2501 * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2502 */2503 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2504 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2505 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2506 return {2507 block: block.toBigInt(),2508 amount: amount.toBigInt(),2509 };2510 });2511 }25122513 /**2514 * Get total pending unstake amount for address2515 * @param address substrate or ethereum address2516 * @returns total pending unstake amount2517 */2518 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2519 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2520 }25212522 /**2523 * Get pending unstake amount per block for address2524 * @param address substrate or ethereum address2525 * @returns array of pending stakes. `block` – the number of the block in which the unstake was made. `amount` - the number of tokens unstaked in the block2526 */2527 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2528 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2529 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2530 return {2531 block: block.toBigInt(),2532 amount: amount.toBigInt(),2533 };2534 });2535 return result;2536 }2537}25382539class SchedulerGroup extends HelperGroup<UniqueHelper> {2540 constructor(helper: UniqueHelper) {2541 super(helper);2542 }25432544 cancelScheduled(signer: TSigner, scheduledId: string) {2545 return this.helper.executeExtrinsic(2546 signer,2547 'api.tx.scheduler.cancelNamed',2548 [scheduledId],2549 true,2550 );2551 }25522553 changePriority(signer: TSigner, scheduledId: string, priority: number) {2554 return this.helper.executeExtrinsic(2555 signer,2556 'api.tx.scheduler.changeNamedPriority',2557 [scheduledId, priority],2558 true,2559 );2560 }25612562 scheduleAt<T extends UniqueHelper>(2563 executionBlockNumber: number,2564 options: ISchedulerOptions = {},2565 ) {2566 return this.schedule<T>('schedule', executionBlockNumber, options);2567 }25682569 scheduleAfter<T extends UniqueHelper>(2570 blocksBeforeExecution: number,2571 options: ISchedulerOptions = {},2572 ) {2573 return this.schedule<T>('scheduleAfter', blocksBeforeExecution, options);2574 }25752576 schedule<T extends UniqueHelper>(2577 scheduleFn: 'schedule' | 'scheduleAfter',2578 blocksNum: number,2579 options: ISchedulerOptions = {},2580 ) {2581 // eslint-disable-next-line @typescript-eslint/naming-convention2582 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2583 return this.helper.clone(ScheduledHelperType, {2584 scheduleFn,2585 blocksNum,2586 options,2587 }) as T;2588 }2589}25902591class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2592 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2593 await this.helper.executeExtrinsic(2594 signer,2595 'api.tx.foreignAssets.registerForeignAsset',2596 [ownerAddress, location, metadata],2597 true,2598 );2599 }26002601 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2602 await this.helper.executeExtrinsic(2603 signer,2604 'api.tx.foreignAssets.updateForeignAsset',2605 [foreignAssetId, location, metadata],2606 true,2607 );2608 }2609}26102611class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2612 palletName: string;26132614 constructor(helper: T, palletName: string) {2615 super(helper);26162617 this.palletName = palletName;2618 }26192620 async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: number) {2621 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, {Limited: weightLimit}], true);2622 }2623}26242625class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2626 async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: number) {2627 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);2628 }26292630 async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: number) {2631 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);2632 }26332634 async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: number) {2635 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);2636 }2637}26382639class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2640 async accounts(address: string, currencyId: any) {2641 const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;2642 return BigInt(free);2643 }2644}26452646class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {2647 async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {2648 await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);2649 }26502651 async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {2652 await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);2653 }26542655 async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {2656 await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);2657 }26582659 async account(assetId: string | number, address: string) {2660 const accountAsset = (2661 await this.helper.callRpc('api.query.assets.account', [assetId, address])2662 ).toJSON()! as any;26632664 if (accountAsset !== null) {2665 return BigInt(accountAsset['balance']);2666 } else {2667 return null;2668 }2669 }2670}26712672class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {2673 async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {2674 await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);2675 }2676}26772678class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {2679 makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {2680 const apiPrefix = 'api.tx.assetManager.';26812682 const registerTx = this.helper.constructApiCall(2683 apiPrefix + 'registerForeignAsset',2684 [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],2685 );26862687 const setUnitsTx = this.helper.constructApiCall(2688 apiPrefix + 'setAssetUnitsPerSecond',2689 [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],2690 );26912692 const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);2693 const encodedProposal = batchCall?.method.toHex() || '';2694 return encodedProposal;2695 }26962697 async assetTypeId(location: any) {2698 return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);2699 }2700}27012702class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {2703 async notePreimage(signer: TSigner, encodedProposal: string) {2704 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.notePreimage', [encodedProposal], true);2705 }27062707 externalProposeMajority(proposalHash: string) {2708 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposalHash]);2709 }27102711 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {2712 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);2713 }27142715 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {2716 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);2717 }2718}27192720class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {2721 collective: string;27222723 constructor(helper: MoonbeamHelper, collective: string) {2724 super(helper);27252726 this.collective = collective;2727 }27282729 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {2730 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);2731 }27322733 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {2734 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);2735 }27362737 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: number, lengthBound: number) {2738 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);2739 }27402741 async proposalCount() {2742 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));2743 }2744}27452746export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;2747export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;27482749export class UniqueHelper extends ChainHelperBase {2750 balance: BalanceGroup<UniqueHelper>;2751 collection: CollectionGroup;2752 nft: NFTGroup;2753 rft: RFTGroup;2754 ft: FTGroup;2755 staking: StakingGroup;2756 scheduler: SchedulerGroup;2757 foreignAssets: ForeignAssetsGroup;2758 xcm: XcmGroup<UniqueHelper>;2759 xTokens: XTokensGroup<UniqueHelper>;2760 tokens: TokensGroup<UniqueHelper>;27612762 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2763 super(logger, options.helperBase ?? UniqueHelper);27642765 this.balance = new BalanceGroup(this);2766 this.collection = new CollectionGroup(this);2767 this.nft = new NFTGroup(this);2768 this.rft = new RFTGroup(this);2769 this.ft = new FTGroup(this);2770 this.staking = new StakingGroup(this);2771 this.scheduler = new SchedulerGroup(this);2772 this.foreignAssets = new ForeignAssetsGroup(this);2773 this.xcm = new XcmGroup(this, 'polkadotXcm');2774 this.xTokens = new XTokensGroup(this);2775 this.tokens = new TokensGroup(this);2776 }27772778 getSudo<T extends UniqueHelper>() {2779 // eslint-disable-next-line @typescript-eslint/naming-convention2780 const SudoHelperType = SudoHelper(this.helperBase);2781 return this.clone(SudoHelperType) as T;2782 }2783}27842785export class XcmChainHelper extends ChainHelperBase {2786 async connect(wsEndpoint: string, _listeners?: any): Promise<void> {2787 const wsProvider = new WsProvider(wsEndpoint);2788 this.api = new ApiPromise({2789 provider: wsProvider,2790 });2791 await this.api.isReadyOrError;2792 this.network = await UniqueHelper.detectNetwork(this.api);2793 }2794}27952796export class RelayHelper extends XcmChainHelper {2797 xcm: XcmGroup<RelayHelper>;27982799 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2800 super(logger, options.helperBase ?? RelayHelper);28012802 this.xcm = new XcmGroup(this, 'xcmPallet');2803 }2804}28052806export class WestmintHelper extends XcmChainHelper {2807 balance: SubstrateBalanceGroup<WestmintHelper>;2808 xcm: XcmGroup<WestmintHelper>;2809 assets: AssetsGroup<WestmintHelper>;2810 xTokens: XTokensGroup<WestmintHelper>;28112812 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2813 super(logger, options.helperBase ?? WestmintHelper);28142815 this.balance = new SubstrateBalanceGroup(this);2816 this.xcm = new XcmGroup(this, 'polkadotXcm');2817 this.assets = new AssetsGroup(this);2818 this.xTokens = new XTokensGroup(this);2819 }2820}28212822export class MoonbeamHelper extends XcmChainHelper {2823 balance: EthereumBalanceGroup<MoonbeamHelper>;2824 assetManager: MoonbeamAssetManagerGroup;2825 assets: AssetsGroup<MoonbeamHelper>;2826 xTokens: XTokensGroup<MoonbeamHelper>;2827 democracy: MoonbeamDemocracyGroup;2828 collective: {2829 council: MoonbeamCollectiveGroup,2830 techCommittee: MoonbeamCollectiveGroup,2831 };28322833 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2834 super(logger, options.helperBase ?? MoonbeamHelper);28352836 this.balance = new EthereumBalanceGroup(this);2837 this.assetManager = new MoonbeamAssetManagerGroup(this);2838 this.assets = new AssetsGroup(this);2839 this.xTokens = new XTokensGroup(this);2840 this.democracy = new MoonbeamDemocracyGroup(this);2841 this.collective = {2842 council: new MoonbeamCollectiveGroup(this, 'councilCollective'),2843 techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),2844 };2845 }2846}28472848export class AcalaHelper extends XcmChainHelper {2849 balance: SubstrateBalanceGroup<AcalaHelper>;2850 assetRegistry: AcalaAssetRegistryGroup;2851 xTokens: XTokensGroup<AcalaHelper>;2852 tokens: TokensGroup<AcalaHelper>;28532854 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2855 super(logger, options.helperBase ?? AcalaHelper);28562857 this.balance = new SubstrateBalanceGroup(this);2858 this.assetRegistry = new AcalaAssetRegistryGroup(this);2859 this.xTokens = new XTokensGroup(this);2860 this.tokens = new TokensGroup(this);2861 }28622863 getSudo<T extends AcalaHelper>() {2864 // eslint-disable-next-line @typescript-eslint/naming-convention2865 const SudoHelperType = SudoHelper(this.helperBase);2866 return this.clone(SudoHelperType) as T;2867 }2868}28692870// eslint-disable-next-line @typescript-eslint/naming-convention2871function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {2872 return class extends Base {2873 scheduleFn: 'schedule' | 'scheduleAfter';2874 blocksNum: number;2875 options: ISchedulerOptions;28762877 constructor(...args: any[]) {2878 const logger = args[0] as ILogger;2879 const options = args[1] as {2880 scheduleFn: 'schedule' | 'scheduleAfter',2881 blocksNum: number,2882 options: ISchedulerOptions2883 };28842885 super(logger);28862887 this.scheduleFn = options.scheduleFn;2888 this.blocksNum = options.blocksNum;2889 this.options = options.options;2890 }28912892 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {2893 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);2894 2895 const mandatorySchedArgs = [2896 this.blocksNum,2897 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,2898 this.options.priority ?? null,2899 scheduledTx,2900 ];2901 2902 let schedArgs;2903 let scheduleFn;29042905 if (this.options.scheduledId) {2906 schedArgs = [this.options.scheduledId!, ...mandatorySchedArgs];29072908 if (this.scheduleFn == 'schedule') {2909 scheduleFn = 'scheduleNamed';2910 } else if (this.scheduleFn == 'scheduleAfter') {2911 scheduleFn = 'scheduleNamedAfter';2912 }2913 } else {2914 schedArgs = mandatorySchedArgs;2915 scheduleFn = this.scheduleFn;2916 }29172918 const extrinsic = 'api.tx.scheduler.' + scheduleFn;29192920 return super.executeExtrinsic(2921 sender,2922 extrinsic,2923 schedArgs,2924 expectSuccess,2925 );2926 }2927 };2928}29292930// eslint-disable-next-line @typescript-eslint/naming-convention2931function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {2932 return class extends Base {2933 constructor(...args: any[]) {2934 super(...args);2935 }29362937 executeExtrinsic (2938 sender: IKeyringPair,2939 extrinsic: string,2940 params: any[],2941 expectSuccess?: boolean,2942 ): Promise<ITransactionResult> {2943 const call = this.constructApiCall(extrinsic, params);2944 return super.executeExtrinsic(2945 sender,2946 'api.tx.sudo.sudo',2947 [call],2948 expectSuccess,2949 );2950 }2951 };2952}29532954export class UniqueBaseCollection {2955 helper: UniqueHelper;2956 collectionId: number;29572958 constructor(collectionId: number, uniqueHelper: UniqueHelper) {2959 this.collectionId = collectionId;2960 this.helper = uniqueHelper;2961 }29622963 async getData() {2964 return await this.helper.collection.getData(this.collectionId);2965 }29662967 async getLastTokenId() {2968 return await this.helper.collection.getLastTokenId(this.collectionId);2969 }29702971 async doesTokenExist(tokenId: number) {2972 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);2973 }29742975 async getAdmins() {2976 return await this.helper.collection.getAdmins(this.collectionId);2977 }29782979 async getAllowList() {2980 return await this.helper.collection.getAllowList(this.collectionId);2981 }29822983 async getEffectiveLimits() {2984 return await this.helper.collection.getEffectiveLimits(this.collectionId);2985 }29862987 async getProperties(propertyKeys?: string[] | null) {2988 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);2989 }29902991 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {2992 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);2993 }29942995 async getOptions() {2996 return await this.helper.collection.getCollectionOptions(this.collectionId);2997 }29982999 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {3000 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);3001 }30023003 async confirmSponsorship(signer: TSigner) {3004 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);3005 }30063007 async removeSponsor(signer: TSigner) {3008 return await this.helper.collection.removeSponsor(signer, this.collectionId);3009 }30103011 async setLimits(signer: TSigner, limits: ICollectionLimits) {3012 return await this.helper.collection.setLimits(signer, this.collectionId, limits);3013 }30143015 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {3016 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);3017 }30183019 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3020 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);3021 }30223023 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {3024 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);3025 }30263027 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {3028 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);3029 }30303031 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3032 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);3033 }30343035 async setProperties(signer: TSigner, properties: IProperty[]) {3036 return await this.helper.collection.setProperties(signer, this.collectionId, properties);3037 }30383039 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3040 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);3041 }30423043 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {3044 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);3045 }30463047 async enableNesting(signer: TSigner, permissions: INestingPermissions) {3048 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);3049 }30503051 async disableNesting(signer: TSigner) {3052 return await this.helper.collection.disableNesting(signer, this.collectionId);3053 }30543055 async burn(signer: TSigner) {3056 return await this.helper.collection.burn(signer, this.collectionId);3057 }30583059 scheduleAt<T extends UniqueHelper>(3060 executionBlockNumber: number,3061 options: ISchedulerOptions = {},3062 ) {3063 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3064 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3065 }30663067 scheduleAfter<T extends UniqueHelper>(3068 blocksBeforeExecution: number,3069 options: ISchedulerOptions = {},3070 ) {3071 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3072 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3073 }30743075 getSudo<T extends UniqueHelper>() {3076 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());3077 }3078}307930803081export class UniqueNFTCollection extends UniqueBaseCollection {3082 getTokenObject(tokenId: number) {3083 return new UniqueNFToken(tokenId, this);3084 }30853086 async getTokensByAddress(addressObj: ICrossAccountId) {3087 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);3088 }30893090 async getToken(tokenId: number, blockHashAt?: string) {3091 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);3092 }30933094 async getTokenOwner(tokenId: number, blockHashAt?: string) {3095 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3096 }30973098 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3099 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3100 }31013102 async getTokenChildren(tokenId: number, blockHashAt?: string) {3103 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);3104 }31053106 async getPropertyPermissions(propertyKeys: string[] | null = null) {3107 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);3108 }31093110 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3111 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3112 }31133114 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {3115 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);3116 }31173118 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3119 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);3120 }31213122 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {3123 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);3124 }31253126 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {3127 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);3128 }31293130 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3131 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});3132 }31333134 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {3135 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);3136 }31373138 async burnToken(signer: TSigner, tokenId: number) {3139 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);3140 }31413142 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {3143 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);3144 }31453146 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3147 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);3148 }31493150 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3151 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3152 }31533154 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3155 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3156 }31573158 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3159 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3160 }31613162 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3163 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3164 }31653166 scheduleAt<T extends UniqueHelper>(3167 executionBlockNumber: number,3168 options: ISchedulerOptions = {},3169 ) {3170 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3171 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3172 }31733174 scheduleAfter<T extends UniqueHelper>(3175 blocksBeforeExecution: number,3176 options: ISchedulerOptions = {},3177 ) {3178 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3179 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3180 }31813182 getSudo<T extends UniqueHelper>() {3183 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());3184 }3185}318631873188export class UniqueRFTCollection extends UniqueBaseCollection {3189 getTokenObject(tokenId: number) {3190 return new UniqueRFToken(tokenId, this);3191 }31923193 async getToken(tokenId: number, blockHashAt?: string) {3194 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);3195 }31963197 async getTokensByAddress(addressObj: ICrossAccountId) {3198 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);3199 }32003201 async getTop10TokenOwners(tokenId: number) {3202 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);3203 }32043205 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {3206 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3207 }32083209 async getTokenTotalPieces(tokenId: number) {3210 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3211 }32123213 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3214 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3215 }32163217 async getPropertyPermissions(propertyKeys: string[] | null = null) {3218 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3219 }32203221 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3222 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3223 }32243225 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3226 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3227 }32283229 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3230 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3231 }32323233 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3234 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3235 }32363237 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3238 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3239 }32403241 async mintToken(signer: TSigner, pieces=1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3242 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3243 }32443245 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3246 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3247 }32483249 async burnToken(signer: TSigner, tokenId: number, amount=1n) {3250 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3251 }32523253 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {3254 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3255 }32563257 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3258 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3259 }32603261 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3262 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3263 }32643265 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3266 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3267 }32683269 scheduleAt<T extends UniqueHelper>(3270 executionBlockNumber: number,3271 options: ISchedulerOptions = {},3272 ) {3273 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3274 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3275 }32763277 scheduleAfter<T extends UniqueHelper>(3278 blocksBeforeExecution: number,3279 options: ISchedulerOptions = {},3280 ) {3281 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3282 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3283 }32843285 getSudo<T extends UniqueHelper>() {3286 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3287 }3288}328932903291export class UniqueFTCollection extends UniqueBaseCollection {3292 async getBalance(addressObj: ICrossAccountId) {3293 return await this.helper.ft.getBalance(this.collectionId, addressObj);3294 }32953296 async getTotalPieces() {3297 return await this.helper.ft.getTotalPieces(this.collectionId);3298 }32993300 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3301 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3302 }33033304 async getTop10Owners() {3305 return await this.helper.ft.getTop10Owners(this.collectionId);3306 }33073308 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3309 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3310 }33113312 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3313 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3314 }33153316 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3317 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3318 }33193320 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3321 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3322 }33233324 async burnTokens(signer: TSigner, amount=1n) {3325 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3326 }33273328 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3329 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3330 }33313332 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3333 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3334 }33353336 scheduleAt<T extends UniqueHelper>(3337 executionBlockNumber: number,3338 options: ISchedulerOptions = {},3339 ) {3340 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3341 return new UniqueFTCollection(this.collectionId, scheduledHelper);3342 }33433344 scheduleAfter<T extends UniqueHelper>(3345 blocksBeforeExecution: number,3346 options: ISchedulerOptions = {},3347 ) {3348 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3349 return new UniqueFTCollection(this.collectionId, scheduledHelper);3350 }33513352 getSudo<T extends UniqueHelper>() {3353 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3354 }3355}335633573358export class UniqueBaseToken {3359 collection: UniqueNFTCollection | UniqueRFTCollection;3360 collectionId: number;3361 tokenId: number;33623363 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3364 this.collection = collection;3365 this.collectionId = collection.collectionId;3366 this.tokenId = tokenId;3367 }33683369 async getNextSponsored(addressObj: ICrossAccountId) {3370 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3371 }33723373 async getProperties(propertyKeys?: string[] | null) {3374 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3375 }33763377 async setProperties(signer: TSigner, properties: IProperty[]) {3378 return await this.collection.setTokenProperties(signer, this.tokenId, properties);3379 }33803381 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3382 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3383 }33843385 async doesExist() {3386 return await this.collection.doesTokenExist(this.tokenId);3387 }33883389 nestingAccount() {3390 return this.collection.helper.util.getTokenAccount(this);3391 }33923393 scheduleAt<T extends UniqueHelper>(3394 executionBlockNumber: number,3395 options: ISchedulerOptions = {},3396 ) {3397 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3398 return new UniqueBaseToken(this.tokenId, scheduledCollection);3399 }34003401 scheduleAfter<T extends UniqueHelper>(3402 blocksBeforeExecution: number,3403 options: ISchedulerOptions = {},3404 ) {3405 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3406 return new UniqueBaseToken(this.tokenId, scheduledCollection);3407 }34083409 getSudo<T extends UniqueHelper>() {3410 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3411 }3412}341334143415export class UniqueNFToken extends UniqueBaseToken {3416 collection: UniqueNFTCollection;34173418 constructor(tokenId: number, collection: UniqueNFTCollection) {3419 super(tokenId, collection);3420 this.collection = collection;3421 }34223423 async getData(blockHashAt?: string) {3424 return await this.collection.getToken(this.tokenId, blockHashAt);3425 }34263427 async getOwner(blockHashAt?: string) {3428 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3429 }34303431 async getTopmostOwner(blockHashAt?: string) {3432 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3433 }34343435 async getChildren(blockHashAt?: string) {3436 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3437 }34383439 async nest(signer: TSigner, toTokenObj: IToken) {3440 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3441 }34423443 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3444 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3445 }34463447 async transfer(signer: TSigner, addressObj: ICrossAccountId) {3448 return await this.collection.transferToken(signer, this.tokenId, addressObj);3449 }34503451 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3452 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3453 }34543455 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3456 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3457 }34583459 async isApproved(toAddressObj: ICrossAccountId) {3460 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3461 }34623463 async burn(signer: TSigner) {3464 return await this.collection.burnToken(signer, this.tokenId);3465 }34663467 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3468 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3469 }34703471 scheduleAt<T extends UniqueHelper>(3472 executionBlockNumber: number,3473 options: ISchedulerOptions = {},3474 ) {3475 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3476 return new UniqueNFToken(this.tokenId, scheduledCollection);3477 }34783479 scheduleAfter<T extends UniqueHelper>(3480 blocksBeforeExecution: number,3481 options: ISchedulerOptions = {},3482 ) {3483 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3484 return new UniqueNFToken(this.tokenId, scheduledCollection);3485 }34863487 getSudo<T extends UniqueHelper>() {3488 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3489 }3490}34913492export class UniqueRFToken extends UniqueBaseToken {3493 collection: UniqueRFTCollection;34943495 constructor(tokenId: number, collection: UniqueRFTCollection) {3496 super(tokenId, collection);3497 this.collection = collection;3498 }34993500 async getData(blockHashAt?: string) {3501 return await this.collection.getToken(this.tokenId, blockHashAt);3502 }35033504 async getTop10Owners() {3505 return await this.collection.getTop10TokenOwners(this.tokenId);3506 }35073508 async getBalance(addressObj: ICrossAccountId) {3509 return await this.collection.getTokenBalance(this.tokenId, addressObj);3510 }35113512 async getTotalPieces() {3513 return await this.collection.getTokenTotalPieces(this.tokenId);3514 }35153516 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {3517 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);3518 }35193520 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {3521 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);3522 }35233524 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3525 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);3526 }35273528 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3529 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);3530 }35313532 async repartition(signer: TSigner, amount: bigint) {3533 return await this.collection.repartitionToken(signer, this.tokenId, amount);3534 }35353536 async burn(signer: TSigner, amount=1n) {3537 return await this.collection.burnToken(signer, this.tokenId, amount);3538 }35393540 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3541 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);3542 }35433544 scheduleAt<T extends UniqueHelper>(3545 executionBlockNumber: number,3546 options: ISchedulerOptions = {},3547 ) {3548 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3549 return new UniqueRFToken(this.tokenId, scheduledCollection);3550 }35513552 scheduleAfter<T extends UniqueHelper>(3553 blocksBeforeExecution: number,3554 options: ISchedulerOptions = {},3555 ) {3556 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3557 return new UniqueRFToken(this.tokenId, scheduledCollection);3558 }35593560 getSudo<T extends UniqueHelper>() {3561 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());3562 }3563}1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// SPDX-License-Identifier: Apache-2.034/* eslint-disable @typescript-eslint/no-var-requires */5/* eslint-disable function-call-argument-newline */6/* eslint-disable no-prototype-builtins */78import {ApiPromise, WsProvider, Keyring} from '@polkadot/api';9import {ApiInterfaceEvents, SignerOptions} from '@polkadot/api/types';10import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm, base58Encode, blake2AsU8a} from '@polkadot/util-crypto';11import {IKeyringPair} from '@polkadot/types/types';12import {hexToU8a} from '@polkadot/util/hex';13import {u8aConcat} from '@polkadot/util/u8a';14import {15 IApiListeners,16 IBlock,17 IEvent,18 IChainProperties,19 ICollectionCreationOptions,20 ICollectionLimits,21 ICollectionPermissions,22 ICrossAccountId,23 ICrossAccountIdLower,24 ILogger,25 INestingPermissions,26 IProperty,27 IStakingInfo,28 ISchedulerOptions,29 ISubstrateBalance,30 IToken,31 ITokenPropertyPermission,32 ITransactionResult,33 IUniqueHelperLog,34 TApiAllowedListeners,35 TEthereumAccount,36 TSigner,37 TSubstrateAccount,38 TNetworks,39 IForeignAssetMetadata,40 AcalaAssetMetadata,41 MoonbeamAssetInfo,42 DemocracyStandardAccountVote,43 IEthCrossAccountId,44} from './types';45import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';4647export class CrossAccountId implements ICrossAccountId {48 Substrate?: TSubstrateAccount;49 Ethereum?: TEthereumAccount;5051 constructor(account: ICrossAccountId) {52 if (account.Substrate) this.Substrate = account.Substrate;53 if (account.Ethereum) this.Ethereum = account.Ethereum;54 }5556 static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {57 switch (domain) {58 case 'Substrate': return new CrossAccountId({Substrate: account.address});59 case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();60 }61 }6263 static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {64 return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});65 }6667 static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {68 return encodeAddress(decodeAddress(address), ss58Format);69 }7071 static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {72 return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});73 }7475 withNormalizedSubstrate(ss58Format = 42): CrossAccountId {76 if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);77 return this;78 }7980 static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {81 return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));82 }8384 toEthereum(): CrossAccountId {85 if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});86 return this;87 }8889 static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {90 return evmToAddress(address, ss58Format);91 }9293 toSubstrate(ss58Format?: number): CrossAccountId {94 if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});95 return this;96 }9798 toLowerCase(): CrossAccountId {99 if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();100 if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();101 return this;102 }103}104105const nesting = {106 toChecksumAddress(address: string): string {107 if (typeof address === 'undefined') return '';108109 if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);110111 address = address.toLowerCase().replace(/^0x/i,'');112 const addressHash = keccakAsHex(address).replace(/^0x/i,'');113 const checksumAddress = ['0x'];114115 for (let i = 0; i < address.length; i++) {116 // If ith character is 8 to f then make it uppercase117 if (parseInt(addressHash[i], 16) > 7) {118 checksumAddress.push(address[i].toUpperCase());119 } else {120 checksumAddress.push(address[i]);121 }122 }123 return checksumAddress.join('');124 },125 tokenIdToAddress(collectionId: number, tokenId: number) {126 return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8,'0')}${tokenId.toString(16).padStart(8,'0')}`);127 },128};129130class UniqueUtil {131 static transactionStatus = {132 NOT_READY: 'NotReady',133 FAIL: 'Fail',134 SUCCESS: 'Success',135 };136137 static chainLogType = {138 EXTRINSIC: 'extrinsic',139 RPC: 'rpc',140 };141142 static getTokenAccount(token: IToken): CrossAccountId {143 return new CrossAccountId({Ethereum: this.getTokenAddress(token)});144 }145146 static getTokenAddress(token: IToken): string {147 return nesting.tokenIdToAddress(token.collectionId, token.tokenId);148 }149150 static getDefaultLogger(): ILogger {151 return {152 log(msg: any, level = 'INFO') {153 console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));154 },155 level: {156 ERROR: 'ERROR',157 WARNING: 'WARNING',158 INFO: 'INFO',159 },160 };161 }162163 static vec2str(arr: string[] | number[]) {164 return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');165 }166167 static str2vec(string: string) {168 if (typeof string !== 'string') return string;169 return Array.from(string).map(x => x.charCodeAt(0));170 }171172 static fromSeed(seed: string, ss58Format = 42) {173 const keyring = new Keyring({type: 'sr25519', ss58Format});174 return keyring.addFromUri(seed);175 }176177 static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {178 if (creationResult.status !== this.transactionStatus.SUCCESS) {179 throw Error('Unable to create collection!');180 }181182 let collectionId = null;183 creationResult.result.events.forEach(({event: {data, method, section}}) => {184 if ((section === 'common') && (method === 'CollectionCreated')) {185 collectionId = parseInt(data[0].toString(), 10);186 }187 });188189 if (collectionId === null) {190 throw Error('No CollectionCreated event was found!');191 }192193 return collectionId;194 }195196 static extractTokensFromCreationResult(creationResult: ITransactionResult): {197 success: boolean,198 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],199 } {200 if (creationResult.status !== this.transactionStatus.SUCCESS) {201 throw Error('Unable to create tokens!');202 }203 let success = false;204 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];205 creationResult.result.events.forEach(({event: {data, method, section}}) => {206 if (method === 'ExtrinsicSuccess') {207 success = true;208 } else if ((section === 'common') && (method === 'ItemCreated')) {209 tokens.push({210 collectionId: parseInt(data[0].toString(), 10),211 tokenId: parseInt(data[1].toString(), 10),212 owner: data[2].toHuman(),213 amount: data[3].toBigInt(),214 });215 }216 });217 return {success, tokens};218 }219220 static extractTokensFromBurnResult(burnResult: ITransactionResult): {221 success: boolean,222 tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],223 } {224 if (burnResult.status !== this.transactionStatus.SUCCESS) {225 throw Error('Unable to burn tokens!');226 }227 let success = false;228 const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];229 burnResult.result.events.forEach(({event: {data, method, section}}) => {230 if (method === 'ExtrinsicSuccess') {231 success = true;232 } else if ((section === 'common') && (method === 'ItemDestroyed')) {233 tokens.push({234 collectionId: parseInt(data[0].toString(), 10),235 tokenId: parseInt(data[1].toString(), 10),236 owner: data[2].toHuman(),237 amount: data[3].toBigInt(),238 });239 }240 });241 return {success, tokens};242 }243244 static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {245 let eventId = null;246 events.forEach(({event: {data, method, section}}) => {247 if ((section === expectedSection) && (method === expectedMethod)) {248 eventId = parseInt(data[0].toString(), 10);249 }250 });251252 if (eventId === null) {253 throw Error(`No ${expectedMethod} event was found!`);254 }255 return eventId === collectionId;256 }257258 static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {259 const normalizeAddress = (address: string | ICrossAccountId) => {260 if(typeof address === 'string') return address;261 const obj = {} as any;262 Object.keys(address).forEach(k => {263 obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];264 });265 if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);266 if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();267 return address;268 };269 let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;270 events.forEach(({event: {data, method, section}}) => {271 if ((section === 'common') && (method === 'Transfer')) {272 const hData = (data as any).toJSON();273 transfer = {274 collectionId: hData[0],275 tokenId: hData[1],276 from: normalizeAddress(hData[2]),277 to: normalizeAddress(hData[3]),278 amount: BigInt(hData[4]),279 };280 }281 });282 let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;283 isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);284 isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);285 isSuccess = isSuccess && amount === transfer.amount;286 return isSuccess;287 }288289 static bigIntToDecimals(number: bigint, decimals = 18) {290 const numberStr = number.toString();291 const dotPos = numberStr.length - decimals;292293 if (dotPos <= 0) {294 return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;295 } else {296 const intPart = numberStr.substring(0, dotPos);297 const fractPart = numberStr.substring(dotPos);298 return intPart + '.' + fractPart;299 }300 }301}302303class UniqueEventHelper {304 private static extractIndex(index: any): [number, number] | string {305 if(index.toRawType() === '[u8;2]') return [index[0], index[1]];306 return index.toJSON();307 }308309 private static extractSub(data: any, subTypes: any): {[key: string]: any} {310 let obj: any = {};311 let index = 0;312313 if (data.entries) {314 for(const [key, value] of data.entries()) {315 obj[key] = this.extractData(value, subTypes[index]);316 index++;317 }318 } else obj = data.toJSON();319320 return obj;321 }322323 private static extractData(data: any, type: any): any {324 if(!type) return data.toHuman();325 if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();326 if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();327 if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);328 return data.toHuman();329 }330331 public static extractEvents(events: {event: any, phase: any}[]): IEvent[] {332 const parsedEvents: IEvent[] = [];333334 events.forEach((record) => {335 const {event, phase} = record;336 const types = event.typeDef;337338 const eventData: IEvent = {339 section: event.section.toString(),340 method: event.method.toString(),341 index: this.extractIndex(event.index),342 data: [],343 phase: phase.toJSON(),344 };345346 event.data.forEach((val: any, index: number) => {347 eventData.data.push(this.extractData(val, types[index]));348 });349350 parsedEvents.push(eventData);351 });352353 return parsedEvents;354 }355}356357export class ChainHelperBase {358 helperBase: any;359360 transactionStatus = UniqueUtil.transactionStatus;361 chainLogType = UniqueUtil.chainLogType;362 util: typeof UniqueUtil;363 eventHelper: typeof UniqueEventHelper;364 logger: ILogger;365 api: ApiPromise | null;366 forcedNetwork: TNetworks | null;367 network: TNetworks | null;368 chainLog: IUniqueHelperLog[];369 children: ChainHelperBase[];370 address: AddressGroup;371 chain: ChainGroup;372373 constructor(logger?: ILogger, helperBase?: any) {374 this.helperBase = helperBase;375376 this.util = UniqueUtil;377 this.eventHelper = UniqueEventHelper;378 if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();379 this.logger = logger;380 this.api = null;381 this.forcedNetwork = null;382 this.network = null;383 this.chainLog = [];384 this.children = [];385 this.address = new AddressGroup(this);386 this.chain = new ChainGroup(this);387 }388389 clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {390 Object.setPrototypeOf(helperCls.prototype, this);391 const newHelper = new helperCls(this.logger, options);392393 newHelper.api = this.api;394 newHelper.network = this.network;395 newHelper.forceNetwork = this.forceNetwork;396397 this.children.push(newHelper);398399 return newHelper;400 }401402 getApi(): ApiPromise {403 if(this.api === null) throw Error('API not initialized');404 return this.api;405 }406407 clearChainLog(): void {408 this.chainLog = [];409 }410411 forceNetwork(value: TNetworks): void {412 this.forcedNetwork = value;413 }414415 async connect(wsEndpoint: string, listeners?: IApiListeners) {416 if (this.api !== null) throw Error('Already connected');417 const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);418 this.api = api;419 this.network = network;420 }421422 async disconnect() {423 for (const child of this.children) {424 child.clearApi();425 }426427 if (this.api === null) return;428 await this.api.disconnect();429 this.clearApi();430 }431432 clearApi() {433 this.api = null;434 this.network = null;435 }436437 static async detectNetwork(api: ApiPromise): Promise<TNetworks> {438 const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;439 const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];440441 if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;442443 if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;444 return 'opal';445 }446447 static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {448 const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});449 await api.isReady;450451 const network = await this.detectNetwork(api);452453 await api.disconnect();454455 return network;456 }457458 static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{459 api: ApiPromise;460 network: TNetworks;461 }> {462 if(typeof network === 'undefined' || network === null) network = 'opal';463 const supportedRPC = {464 opal: {465 unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,466 },467 quartz: {468 unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,469 },470 unique: {471 unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,472 },473 rococo: {},474 westend: {},475 moonbeam: {},476 moonriver: {},477 acala: {},478 karura: {},479 westmint: {},480 };481 if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);482 const rpc = supportedRPC[network];483484 // TODO: investigate how to replace rpc in runtime485 // api._rpcCore.addUserInterfaces(rpc);486487 const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});488489 await api.isReadyOrError;490491 if (typeof listeners === 'undefined') listeners = {};492 for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {493 if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;494 api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);495 }496497 return {api, network};498 }499500 getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {501 const {events, status} = data;502 if (status.isReady) {503 return this.transactionStatus.NOT_READY;504 }505 if (status.isBroadcast) {506 return this.transactionStatus.NOT_READY;507 }508 if (status.isInBlock || status.isFinalized) {509 const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');510 if (errors.length > 0) {511 return this.transactionStatus.FAIL;512 }513 if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {514 return this.transactionStatus.SUCCESS;515 }516 }517518 return this.transactionStatus.FAIL;519 }520521 signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {522 const sign = (callback: any) => {523 if(options !== null) return transaction.signAndSend(sender, options, callback);524 return transaction.signAndSend(sender, callback);525 };526 // eslint-disable-next-line no-async-promise-executor527 return new Promise(async (resolve, reject) => {528 try {529 const unsub = await sign((result: any) => {530 const status = this.getTransactionStatus(result);531532 if (status === this.transactionStatus.SUCCESS) {533 this.logger.log(`${label} successful`);534 unsub();535 resolve({result, status});536 } else if (status === this.transactionStatus.FAIL) {537 let moduleError = null;538539 if (result.hasOwnProperty('dispatchError')) {540 const dispatchError = result['dispatchError'];541542 if (dispatchError) {543 if (dispatchError.isModule) {544 const modErr = dispatchError.asModule;545 const errorMeta = dispatchError.registry.findMetaError(modErr);546547 moduleError = `${errorMeta.section}.${errorMeta.name}`;548 } else {549 moduleError = dispatchError.toHuman();550 }551 } else {552 this.logger.log(result, this.logger.level.ERROR);553 }554 }555556 this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);557 unsub();558 reject({status, moduleError, result});559 }560 });561 } catch (e) {562 this.logger.log(e, this.logger.level.ERROR);563 reject(e);564 }565 });566 }567568 async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {569 const api = this.getApi();570 const signingInfo = await api.derive.tx.signingInfo(signer.address);571572 // We need to sign the tx because573 // unsigned transactions does not have an inclusion fee574 tx.sign(signer, {575 blockHash: api.genesisHash,576 genesisHash: api.genesisHash,577 runtimeVersion: api.runtimeVersion,578 nonce: signingInfo.nonce,579 });580581 if (len === null) {582 return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;583 } else {584 return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;585 }586 }587588 constructApiCall(apiCall: string, params: any[]) {589 if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);590 let call = this.getApi() as any;591 for(const part of apiCall.slice(4).split('.')) {592 call = call[part];593 }594 return call(...params);595 }596597 async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {598 if(this.api === null) throw Error('API not initialized');599 if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);600601 const startTime = (new Date()).getTime();602 let result: ITransactionResult;603 let events: IEvent[] = [];604 try {605 result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;606 events = this.eventHelper.extractEvents(result.result.events);607 }608 catch(e) {609 if(!(e as object).hasOwnProperty('status')) throw e;610 result = e as ITransactionResult;611 }612613 const endTime = (new Date()).getTime();614615 const log = {616 executedAt: endTime,617 executionTime: endTime - startTime,618 type: this.chainLogType.EXTRINSIC,619 status: result.status,620 call: extrinsic,621 signer: this.getSignerAddress(sender),622 params,623 } as IUniqueHelperLog;624625 if(result.status !== this.transactionStatus.SUCCESS) {626 if (result.moduleError) log.moduleError = result.moduleError;627 else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;628 }629 if(events.length > 0) log.events = events;630631 this.chainLog.push(log);632633 if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {634 if (result.moduleError) throw Error(`${result.moduleError}`);635 else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));636 }637 return result;638 }639640 async callRpc(rpc: string, params?: any[]) {641 if(typeof params === 'undefined') params = [];642 if(this.api === null) throw Error('API not initialized');643 if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);644645 const startTime = (new Date()).getTime();646 let result;647 let error = null;648 const log = {649 type: this.chainLogType.RPC,650 call: rpc,651 params,652 } as IUniqueHelperLog;653654 try {655 result = await this.constructApiCall(rpc, params);656 }657 catch(e) {658 error = e;659 }660661 const endTime = (new Date()).getTime();662663 log.executedAt = endTime;664 log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';665 log.executionTime = endTime - startTime;666667 this.chainLog.push(log);668669 if(error !== null) throw error;670671 return result;672 }673674 getSignerAddress(signer: IKeyringPair | string): string {675 if(typeof signer === 'string') return signer;676 return signer.address;677 }678679 fetchAllPalletNames(): string[] {680 if(this.api === null) throw Error('API not initialized');681 return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());682 }683684 fetchMissingPalletNames(requiredPallets: string[]): string[] {685 const palletNames = this.fetchAllPalletNames();686 return requiredPallets.filter(p => !palletNames.includes(p));687 }688}689690691class HelperGroup<T extends ChainHelperBase> {692 helper: T;693694 constructor(uniqueHelper: T) {695 this.helper = uniqueHelper;696 }697}698699700class CollectionGroup extends HelperGroup<UniqueHelper> {701 /**702 * Get number of blocks when sponsored transaction is available.703 *704 * @param collectionId ID of collection705 * @param tokenId ID of token706 * @param addressObj address for which the sponsorship is checked707 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});708 * @returns number of blocks or null if sponsorship hasn't been set709 */710 async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {711 return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();712 }713714 /**715 * Get the number of created collections.716 *717 * @returns number of created collections718 */719 async getTotalCount(): Promise<number> {720 return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();721 }722723 /**724 * Get information about the collection with additional data,725 * including the number of tokens it contains, its administrators,726 * the normalized address of the collection's owner, and decoded name and description.727 *728 * @param collectionId ID of collection729 * @example await getData(2)730 * @returns collection information object731 */732 async getData(collectionId: number): Promise<{733 id: number;734 name: string;735 description: string;736 tokensCount: number;737 admins: CrossAccountId[];738 normalizedOwner: TSubstrateAccount;739 raw: any740 } | null> {741 const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);742 const humanCollection = collection.toHuman(), collectionData = {743 id: collectionId, name: null, description: null, tokensCount: 0, admins: [],744 raw: humanCollection,745 } as any, jsonCollection = collection.toJSON();746 if (humanCollection === null) return null;747 collectionData.raw.limits = jsonCollection.limits;748 collectionData.raw.permissions = jsonCollection.permissions;749 collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);750 for (const key of ['name', 'description']) {751 collectionData[key] = this.helper.util.vec2str(humanCollection[key]);752 }753754 collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))755 ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)756 : 0;757 collectionData.admins = await this.getAdmins(collectionId);758759 return collectionData;760 }761762 /**763 * Get the addresses of the collection's administrators, optionally normalized.764 *765 * @param collectionId ID of collection766 * @param normalize whether to normalize the addresses to the default ss58 format767 * @example await getAdmins(1)768 * @returns array of administrators769 */770 async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {771 const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();772773 return normalize774 ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())775 : admins;776 }777778 /**779 * Get the addresses added to the collection allow-list, optionally normalized.780 * @param collectionId ID of collection781 * @param normalize whether to normalize the addresses to the default ss58 format782 * @example await getAllowList(1)783 * @returns array of allow-listed addresses784 */785 async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {786 const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();787 return normalize788 ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())789 : allowListed;790 }791792 /**793 * Get the effective limits of the collection instead of null for default values794 *795 * @param collectionId ID of collection796 * @example await getEffectiveLimits(2)797 * @returns object of collection limits798 */799 async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {800 return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();801 }802803 /**804 * Burns the collection if the signer has sufficient permissions and collection is empty.805 *806 * @param signer keyring of signer807 * @param collectionId ID of collection808 * @example await helper.collection.burn(aliceKeyring, 3);809 * @returns ```true``` if extrinsic success, otherwise ```false```810 */811 async burn(signer: TSigner, collectionId: number): Promise<boolean> {812 const result = await this.helper.executeExtrinsic(813 signer,814 'api.tx.unique.destroyCollection', [collectionId],815 true,816 );817818 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');819 }820821 /**822 * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.823 *824 * @param signer keyring of signer825 * @param collectionId ID of collection826 * @param sponsorAddress Sponsor substrate address827 * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")828 * @returns ```true``` if extrinsic success, otherwise ```false```829 */830 async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {831 const result = await this.helper.executeExtrinsic(832 signer,833 'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],834 true,835 );836837 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorSet');838 }839840 /**841 * Confirms consent to sponsor the collection on behalf of the signer.842 *843 * @param signer keyring of signer844 * @param collectionId ID of collection845 * @example confirmSponsorship(aliceKeyring, 10)846 * @returns ```true``` if extrinsic success, otherwise ```false```847 */848 async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {849 const result = await this.helper.executeExtrinsic(850 signer,851 'api.tx.unique.confirmSponsorship', [collectionId],852 true,853 );854855 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'SponsorshipConfirmed');856 }857858 /**859 * Removes the sponsor of a collection, regardless if it consented or not.860 *861 * @param signer keyring of signer862 * @param collectionId ID of collection863 * @example removeSponsor(aliceKeyring, 10)864 * @returns ```true``` if extrinsic success, otherwise ```false```865 */866 async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {867 const result = await this.helper.executeExtrinsic(868 signer,869 'api.tx.unique.removeCollectionSponsor', [collectionId],870 true,871 );872873 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorRemoved');874 }875876 /**877 * Sets the limits of the collection. At least one limit must be specified for a correct call.878 *879 * @param signer keyring of signer880 * @param collectionId ID of collection881 * @param limits collection limits object882 * @example883 * await setLimits(884 * aliceKeyring,885 * 10,886 * {887 * sponsorTransferTimeout: 0,888 * ownerCanDestroy: false889 * }890 * )891 * @returns ```true``` if extrinsic success, otherwise ```false```892 */893 async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {894 const result = await this.helper.executeExtrinsic(895 signer,896 'api.tx.unique.setCollectionLimits', [collectionId, limits],897 true,898 );899900 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionLimitSet');901 }902903 /**904 * Changes the owner of the collection to the new Substrate address.905 *906 * @param signer keyring of signer907 * @param collectionId ID of collection908 * @param ownerAddress substrate address of new owner909 * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")910 * @returns ```true``` if extrinsic success, otherwise ```false```911 */912 async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {913 const result = await this.helper.executeExtrinsic(914 signer,915 'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],916 true,917 );918919 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionOwnedChanged');920 }921922 /**923 * Adds a collection administrator.924 *925 * @param signer keyring of signer926 * @param collectionId ID of collection927 * @param adminAddressObj Administrator address (substrate or ethereum)928 * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})929 * @returns ```true``` if extrinsic success, otherwise ```false```930 */931 async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {932 const result = await this.helper.executeExtrinsic(933 signer,934 'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],935 true,936 );937938 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminAdded');939 }940941 /**942 * Removes a collection administrator.943 *944 * @param signer keyring of signer945 * @param collectionId ID of collection946 * @param adminAddressObj Administrator address (substrate or ethereum)947 * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})948 * @returns ```true``` if extrinsic success, otherwise ```false```949 */950 async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {951 const result = await this.helper.executeExtrinsic(952 signer,953 'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],954 true,955 );956957 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminRemoved');958 }959960 /**961 * Check if user is in allow list.962 *963 * @param collectionId ID of collection964 * @param user Account to check965 * @example await getAdmins(1)966 * @returns is user in allow list967 */968 async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {969 return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();970 }971972 /**973 * Adds an address to allow list974 * @param signer keyring of signer975 * @param collectionId ID of collection976 * @param addressObj address to add to the allow list977 * @returns ```true``` if extrinsic success, otherwise ```false```978 */979 async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {980 const result = await this.helper.executeExtrinsic(981 signer,982 'api.tx.unique.addToAllowList', [collectionId, addressObj],983 true,984 );985986 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressAdded');987 }988989 /**990 * Removes an address from allow list991 *992 * @param signer keyring of signer993 * @param collectionId ID of collection994 * @param addressObj address to remove from the allow list995 * @returns ```true``` if extrinsic success, otherwise ```false```996 */997 async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {998 const result = await this.helper.executeExtrinsic(999 signer,1000 'api.tx.unique.removeFromAllowList', [collectionId, addressObj],1001 true,1002 );10031004 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressRemoved');1005 }10061007 /**1008 * Sets onchain permissions for selected collection.1009 *1010 * @param signer keyring of signer1011 * @param collectionId ID of collection1012 * @param permissions collection permissions object1013 * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});1014 * @returns ```true``` if extrinsic success, otherwise ```false```1015 */1016 async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {1017 const result = await this.helper.executeExtrinsic(1018 signer,1019 'api.tx.unique.setCollectionPermissions', [collectionId, permissions],1020 true,1021 );10221023 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionPermissionSet');1024 }10251026 /**1027 * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.1028 *1029 * @param signer keyring of signer1030 * @param collectionId ID of collection1031 * @param permissions nesting permissions object1032 * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});1033 * @returns ```true``` if extrinsic success, otherwise ```false```1034 */1035 async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1036 return await this.setPermissions(signer, collectionId, {nesting: permissions});1037 }10381039 /**1040 * Disables nesting for selected collection.1041 *1042 * @param signer keyring of signer1043 * @param collectionId ID of collection1044 * @example disableNesting(aliceKeyring, 10);1045 * @returns ```true``` if extrinsic success, otherwise ```false```1046 */1047 async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1048 return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1049 }10501051 /**1052 * Sets onchain properties to the collection.1053 *1054 * @param signer keyring of signer1055 * @param collectionId ID of collection1056 * @param properties array of property objects1057 * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);1058 * @returns ```true``` if extrinsic success, otherwise ```false```1059 */1060 async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1061 const result = await this.helper.executeExtrinsic(1062 signer,1063 'api.tx.unique.setCollectionProperties', [collectionId, properties],1064 true,1065 );10661067 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1068 }10691070 /**1071 * Get collection properties.1072 *1073 * @param collectionId ID of collection1074 * @param propertyKeys optionally filter the returned properties to only these keys1075 * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1076 * @returns array of key-value pairs1077 */1078 async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1079 return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1080 }10811082 async getCollectionOptions(collectionId: number) {1083 return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1084 }10851086 /**1087 * Deletes onchain properties from the collection.1088 *1089 * @param signer keyring of signer1090 * @param collectionId ID of collection1091 * @param propertyKeys array of property keys to delete1092 * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1093 * @returns ```true``` if extrinsic success, otherwise ```false```1094 */1095 async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1096 const result = await this.helper.executeExtrinsic(1097 signer,1098 'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1099 true,1100 );11011102 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1103 }11041105 /**1106 * Changes the owner of the token.1107 *1108 * @param signer keyring of signer1109 * @param collectionId ID of collection1110 * @param tokenId ID of token1111 * @param addressObj address of a new owner1112 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1113 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1114 * @returns true if the token success, otherwise false1115 */1116 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1117 const result = await this.helper.executeExtrinsic(1118 signer,1119 'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1120 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1121 );11221123 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1124 }11251126 /**1127 *1128 * Change ownership of a token(s) on behalf of the owner.1129 *1130 * @param signer keyring of signer1131 * @param collectionId ID of collection1132 * @param tokenId ID of token1133 * @param fromAddressObj address on behalf of which the token will be sent1134 * @param toAddressObj new token owner1135 * @param amount amount of tokens to be transfered. For NFT must be set to 1n1136 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1137 * @returns true if the token success, otherwise false1138 */1139 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1140 const result = await this.helper.executeExtrinsic(1141 signer,1142 'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1143 true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1144 );1145 return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1146 }11471148 /**1149 *1150 * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1151 *1152 * @param signer keyring of signer1153 * @param collectionId ID of collection1154 * @param tokenId ID of token1155 * @param amount amount of tokens to be burned. For NFT must be set to 1n1156 * @example burnToken(aliceKeyring, 10, 5);1157 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1158 */1159 async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1160 const burnResult = await this.helper.executeExtrinsic(1161 signer,1162 'api.tx.unique.burnItem', [collectionId, tokenId, amount],1163 true, // `Unable to burn token for ${label}`,1164 );1165 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1166 if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1167 return burnedTokens.success;1168 }11691170 /**1171 * Destroys a concrete instance of NFT on behalf of the owner1172 *1173 * @param signer keyring of signer1174 * @param collectionId ID of collection1175 * @param tokenId ID of token1176 * @param fromAddressObj address on behalf of which the token will be burnt1177 * @param amount amount of tokens to be burned. For NFT must be set to 1n1178 * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1179 * @returns ```true``` if extrinsic success, otherwise ```false```1180 */1181 async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1182 const burnResult = await this.helper.executeExtrinsic(1183 signer,1184 'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1185 true, // `Unable to burn token from for ${label}`,1186 );1187 const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1188 return burnedTokens.success && burnedTokens.tokens.length > 0;1189 }11901191 /**1192 * Set, change, or remove approved address to transfer the ownership of the NFT.1193 *1194 * @param signer keyring of signer1195 * @param collectionId ID of collection1196 * @param tokenId ID of token1197 * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1198 * @param amount amount of token to be approved. For NFT must be set to 1n1199 * @returns ```true``` if extrinsic success, otherwise ```false```1200 */1201 async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1202 const approveResult = await this.helper.executeExtrinsic(1203 signer,1204 'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1205 true, // `Unable to approve token for ${label}`,1206 );12071208 return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1209 }12101211 /**1212 * Get the amount of token pieces approved to transfer or burn. Normally 0.1213 *1214 * @param collectionId ID of collection1215 * @param tokenId ID of token1216 * @param toAccountObj address which is approved to use token pieces1217 * @param fromAccountObj address which may have allowed the use of its owned tokens1218 * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1219 * @returns number of approved to transfer pieces1220 */1221 async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1222 return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1223 }12241225 /**1226 * Get the last created token ID in a collection1227 *1228 * @param collectionId ID of collection1229 * @example getLastTokenId(10);1230 * @returns id of the last created token1231 */1232 async getLastTokenId(collectionId: number): Promise<number> {1233 return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1234 }12351236 /**1237 * Check if token exists1238 *1239 * @param collectionId ID of collection1240 * @param tokenId ID of token1241 * @example doesTokenExist(10, 20);1242 * @returns true if the token exists, otherwise false1243 */1244 async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1245 return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1246 }1247}12481249class NFTnRFT extends CollectionGroup {1250 /**1251 * Get tokens owned by account1252 *1253 * @param collectionId ID of collection1254 * @param addressObj tokens owner1255 * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1256 * @returns array of token ids owned by account1257 */1258 async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1259 return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1260 }12611262 /**1263 * Get token data1264 *1265 * @param collectionId ID of collection1266 * @param tokenId ID of token1267 * @param propertyKeys optionally filter the token properties to only these keys1268 * @param blockHashAt optionally query the data at some block with this hash1269 * @example getToken(10, 5);1270 * @returns human readable token data1271 */1272 async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1273 properties: IProperty[];1274 owner: CrossAccountId;1275 normalizedOwner: CrossAccountId;1276 }| null> {1277 let tokenData;1278 if(typeof blockHashAt === 'undefined') {1279 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1280 }1281 else {1282 if(propertyKeys.length == 0) {1283 const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1284 if(!collection) return null;1285 propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1286 }1287 tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1288 }1289 tokenData = tokenData.toHuman();1290 if (tokenData === null || tokenData.owner === null) return null;1291 const owner = {} as any;1292 for (const key of Object.keys(tokenData.owner)) {1293 owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'1294 ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])1295 : tokenData.owner[key];1296 }1297 tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1298 return tokenData;1299 }13001301 /**1302 * Set permissions to change token properties1303 *1304 * @param signer keyring of signer1305 * @param collectionId ID of collection1306 * @param permissions permissions to change a property by the collection admin or token owner1307 * @example setTokenPropertyPermissions(1308 * aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1309 * )1310 * @returns true if extrinsic success otherwise false1311 */1312 async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1313 const result = await this.helper.executeExtrinsic(1314 signer,1315 'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1316 true,1317 );13181319 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1320 }13211322 /**1323 * Get token property permissions.1324 *1325 * @param collectionId ID of collection1326 * @param propertyKeys optionally filter the returned property permissions to only these keys1327 * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1328 * @returns array of key-permission pairs1329 */1330 async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1331 return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1332 }13331334 /**1335 * Set token properties1336 *1337 * @param signer keyring of signer1338 * @param collectionId ID of collection1339 * @param tokenId ID of token1340 * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1341 * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1342 * @returns ```true``` if extrinsic success, otherwise ```false```1343 */1344 async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1345 const result = await this.helper.executeExtrinsic(1346 signer,1347 'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1348 true,1349 );13501351 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1352 }13531354 /**1355 * Get properties, metadata assigned to a token.1356 *1357 * @param collectionId ID of collection1358 * @param tokenId ID of token1359 * @param propertyKeys optionally filter the returned properties to only these keys1360 * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1361 * @returns array of key-value pairs1362 */1363 async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1364 return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1365 }13661367 /**1368 * Delete the provided properties of a token1369 * @param signer keyring of signer1370 * @param collectionId ID of collection1371 * @param tokenId ID of token1372 * @param propertyKeys property keys to be deleted1373 * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1374 * @returns ```true``` if extrinsic success, otherwise ```false```1375 */1376 async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1377 const result = await this.helper.executeExtrinsic(1378 signer,1379 'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1380 true,1381 );13821383 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1384 }13851386 /**1387 * Mint new collection1388 *1389 * @param signer keyring of signer1390 * @param collectionOptions basic collection options and properties1391 * @param mode NFT or RFT type of a collection1392 * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1393 * @returns object of the created collection1394 */1395 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1396 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1397 collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1398 for (const key of ['name', 'description', 'tokenPrefix']) {1399 if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);1400 }1401 const creationResult = await this.helper.executeExtrinsic(1402 signer,1403 'api.tx.unique.createCollectionEx', [collectionOptions],1404 true, // errorLabel,1405 );1406 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1407 }14081409 getCollectionObject(_collectionId: number): any {1410 return null;1411 }14121413 getTokenObject(_collectionId: number, _tokenId: number): any {1414 return null;1415 }14161417 /**1418 * Tells whether an operator is approved by a given owner.1419 * @param collectionId ID of collection1420 * @param owner owner address1421 * @param operator operator addrees1422 * @returns true if operator is enabled1423 */1424 async isApprovedForAll(collectionId: number, owner: ICrossAccountId, operator: ICrossAccountId): Promise<boolean> {1425 return (await this.helper.callRpc('api.rpc.unique.isApprovedForAll', [collectionId, owner, operator])).toJSON();1426 }14271428 /** Sets or unsets the approval of a given operator.1429 * An operator is allowed to transfer all tokens of the sender on their behalf.1430 * @param operator Operator1431 * @param approved Is operator enabled or disabled1432 * @returns ```true``` if extrinsic success, otherwise ```false```1433 */1434 async setApprovalForAll(signer: TSigner, collectionId: number, operator: ICrossAccountId, approved: boolean): Promise<boolean> {1435 const result = await this.helper.executeExtrinsic(1436 signer,1437 'api.tx.unique.setApprovalForAll', [collectionId, operator, approved],1438 true,1439 );1440 return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'ApprovedForAll');1441 }1442}144314441445class NFTGroup extends NFTnRFT {1446 /**1447 * Get collection object1448 * @param collectionId ID of collection1449 * @example getCollectionObject(2);1450 * @returns instance of UniqueNFTCollection1451 */1452 getCollectionObject(collectionId: number): UniqueNFTCollection {1453 return new UniqueNFTCollection(collectionId, this.helper);1454 }14551456 /**1457 * Get token object1458 * @param collectionId ID of collection1459 * @param tokenId ID of token1460 * @example getTokenObject(10, 5);1461 * @returns instance of UniqueNFTToken1462 */1463 getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1464 return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1465 }14661467 /**1468 * Get token's owner1469 * @param collectionId ID of collection1470 * @param tokenId ID of token1471 * @param blockHashAt optionally query the data at the block with this hash1472 * @example getTokenOwner(10, 5);1473 * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1474 */1475 async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1476 let owner;1477 if (typeof blockHashAt === 'undefined') {1478 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1479 } else {1480 owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1481 }1482 return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1483 }14841485 /**1486 * Is token approved to transfer1487 * @param collectionId ID of collection1488 * @param tokenId ID of token1489 * @param toAccountObj address to be approved1490 * @returns ```true``` if extrinsic success, otherwise ```false```1491 */1492 async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1493 return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1494 }14951496 /**1497 * Changes the owner of the token.1498 *1499 * @param signer keyring of signer1500 * @param collectionId ID of collection1501 * @param tokenId ID of token1502 * @param addressObj address of a new owner1503 * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1504 * @returns ```true``` if extrinsic success, otherwise ```false```1505 */1506 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1507 return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1508 }15091510 /**1511 *1512 * Change ownership of a NFT on behalf of the owner.1513 *1514 * @param signer keyring of signer1515 * @param collectionId ID of collection1516 * @param tokenId ID of token1517 * @param fromAddressObj address on behalf of which the token will be sent1518 * @param toAddressObj new token owner1519 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1520 * @returns ```true``` if extrinsic success, otherwise ```false```1521 */1522 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1523 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1524 }15251526 /**1527 * Recursively find the address that owns the token1528 * @param collectionId ID of collection1529 * @param tokenId ID of token1530 * @param blockHashAt1531 * @example getTokenTopmostOwner(10, 5);1532 * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1533 */1534 async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1535 let owner;1536 if (typeof blockHashAt === 'undefined') {1537 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1538 } else {1539 owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1540 }15411542 if (owner === null) return null;15431544 return owner.toHuman();1545 }15461547 /**1548 * Get tokens nested in the provided token1549 * @param collectionId ID of collection1550 * @param tokenId ID of token1551 * @param blockHashAt optionally query the data at the block with this hash1552 * @example getTokenChildren(10, 5);1553 * @returns tokens whose depth of nesting is <= 51554 */1555 async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1556 let children;1557 if(typeof blockHashAt === 'undefined') {1558 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1559 } else {1560 children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1561 }15621563 return children.toJSON().map((x: any) => {1564 return {collectionId: x.collection, tokenId: x.token};1565 });1566 }15671568 /**1569 * Nest one token into another1570 * @param signer keyring of signer1571 * @param tokenObj token to be nested1572 * @param rootTokenObj token to be parent1573 * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1574 * @returns ```true``` if extrinsic success, otherwise ```false```1575 */1576 async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1577 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1578 const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1579 if(!result) {1580 throw Error('Unable to nest token!');1581 }1582 return result;1583 }15841585 /**1586 * Remove token from nested state1587 * @param signer keyring of signer1588 * @param tokenObj token to unnest1589 * @param rootTokenObj parent of a token1590 * @param toAddressObj address of a new token owner1591 * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1592 * @returns ```true``` if extrinsic success, otherwise ```false```1593 */1594 async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1595 const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1596 const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1597 if(!result) {1598 throw Error('Unable to unnest token!');1599 }1600 return result;1601 }16021603 /**1604 * Mint new collection1605 * @param signer keyring of signer1606 * @param collectionOptions Collection options1607 * @example1608 * mintCollection(aliceKeyring, {1609 * name: 'New',1610 * description: 'New collection',1611 * tokenPrefix: 'NEW',1612 * })1613 * @returns object of the created collection1614 */1615 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1616 return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1617 }16181619 /**1620 * Mint new token1621 * @param signer keyring of signer1622 * @param data token data1623 * @returns created token object1624 */1625 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1626 const creationResult = await this.helper.executeExtrinsic(1627 signer,1628 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1629 nft: {1630 properties: data.properties,1631 },1632 }],1633 true,1634 );1635 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1636 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1637 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1638 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1639 }16401641 /**1642 * Mint multiple NFT tokens1643 * @param signer keyring of signer1644 * @param collectionId ID of collection1645 * @param tokens array of tokens with owner and properties1646 * @example1647 * mintMultipleTokens(aliceKeyring, 10, [{1648 * owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1649 * properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1650 * },{1651 * owner: {Ethereum: "0x9F0583DbB855d..."},1652 * properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1653 * }]);1654 * @returns ```true``` if extrinsic success, otherwise ```false```1655 */1656 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1657 const creationResult = await this.helper.executeExtrinsic(1658 signer,1659 'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1660 true,1661 );1662 const collection = this.getCollectionObject(collectionId);1663 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1664 }16651666 /**1667 * Mint multiple NFT tokens with one owner1668 * @param signer keyring of signer1669 * @param collectionId ID of collection1670 * @param owner tokens owner1671 * @param tokens array of tokens with owner and properties1672 * @example1673 * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1674 * properties: [{1675 * key: "gender",1676 * value: "female",1677 * },{1678 * key: "age",1679 * value: "33",1680 * }],1681 * }]);1682 * @returns array of newly created tokens1683 */1684 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1685 const rawTokens = [];1686 for (const token of tokens) {1687 const raw = {NFT: {properties: token.properties}};1688 rawTokens.push(raw);1689 }1690 const creationResult = await this.helper.executeExtrinsic(1691 signer,1692 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1693 true,1694 );1695 const collection = this.getCollectionObject(collectionId);1696 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1697 }16981699 /**1700 * Set, change, or remove approved address to transfer the ownership of the NFT.1701 *1702 * @param signer keyring of signer1703 * @param collectionId ID of collection1704 * @param tokenId ID of token1705 * @param toAddressObj address to approve1706 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1707 * @returns ```true``` if extrinsic success, otherwise ```false```1708 */1709 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId) {1710 return super.approveToken(signer, collectionId, tokenId, toAddressObj, 1n);1711 }1712}171317141715class RFTGroup extends NFTnRFT {1716 /**1717 * Get collection object1718 * @param collectionId ID of collection1719 * @example getCollectionObject(2);1720 * @returns instance of UniqueRFTCollection1721 */1722 getCollectionObject(collectionId: number): UniqueRFTCollection {1723 return new UniqueRFTCollection(collectionId, this.helper);1724 }17251726 /**1727 * Get token object1728 * @param collectionId ID of collection1729 * @param tokenId ID of token1730 * @example getTokenObject(10, 5);1731 * @returns instance of UniqueNFTToken1732 */1733 getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1734 return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1735 }17361737 /**1738 * Get top 10 token owners with the largest number of pieces1739 * @param collectionId ID of collection1740 * @param tokenId ID of token1741 * @example getTokenTop10Owners(10, 5);1742 * @returns array of top 10 owners1743 */1744 async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1745 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1746 }17471748 /**1749 * Get number of pieces owned by address1750 * @param collectionId ID of collection1751 * @param tokenId ID of token1752 * @param addressObj address token owner1753 * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1754 * @returns number of pieces ownerd by address1755 */1756 async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1757 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1758 }17591760 /**1761 * Transfer pieces of token to another address1762 * @param signer keyring of signer1763 * @param collectionId ID of collection1764 * @param tokenId ID of token1765 * @param addressObj address of a new owner1766 * @param amount number of pieces to be transfered1767 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1768 * @returns ```true``` if extrinsic success, otherwise ```false```1769 */1770 async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1771 return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1772 }17731774 /**1775 * Change ownership of some pieces of RFT on behalf of the owner.1776 * @param signer keyring of signer1777 * @param collectionId ID of collection1778 * @param tokenId ID of token1779 * @param fromAddressObj address on behalf of which the token will be sent1780 * @param toAddressObj new token owner1781 * @param amount number of pieces to be transfered1782 * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1783 * @returns ```true``` if extrinsic success, otherwise ```false```1784 */1785 async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1786 return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1787 }17881789 /**1790 * Mint new collection1791 * @param signer keyring of signer1792 * @param collectionOptions Collection options1793 * @example1794 * mintCollection(aliceKeyring, {1795 * name: 'New',1796 * description: 'New collection',1797 * tokenPrefix: 'NEW',1798 * })1799 * @returns object of the created collection1800 */1801 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1802 return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1803 }18041805 /**1806 * Mint new token1807 * @param signer keyring of signer1808 * @param data token data1809 * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1810 * @returns created token object1811 */1812 async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1813 const creationResult = await this.helper.executeExtrinsic(1814 signer,1815 'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1816 refungible: {1817 pieces: data.pieces,1818 properties: data.properties,1819 },1820 }],1821 true,1822 );1823 const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1824 if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1825 if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1826 return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1827 }18281829 async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1830 throw Error('Not implemented');1831 const creationResult = await this.helper.executeExtrinsic(1832 signer,1833 'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1834 true, // `Unable to mint RFT tokens for ${label}`,1835 );1836 const collection = this.getCollectionObject(collectionId);1837 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1838 }18391840 /**1841 * Mint multiple RFT tokens with one owner1842 * @param signer keyring of signer1843 * @param collectionId ID of collection1844 * @param owner tokens owner1845 * @param tokens array of tokens with properties and pieces1846 * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1847 * @returns array of newly created RFT tokens1848 */1849 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1850 const rawTokens = [];1851 for (const token of tokens) {1852 const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1853 rawTokens.push(raw);1854 }1855 const creationResult = await this.helper.executeExtrinsic(1856 signer,1857 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1858 true,1859 );1860 const collection = this.getCollectionObject(collectionId);1861 return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1862 }18631864 /**1865 * Destroys a concrete instance of RFT.1866 * @param signer keyring of signer1867 * @param collectionId ID of collection1868 * @param tokenId ID of token1869 * @param amount number of pieces to be burnt1870 * @example burnToken(aliceKeyring, 10, 5);1871 * @returns ```true``` if the extrinsic is successful, otherwise ```false```1872 */1873 async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1874 return await super.burnToken(signer, collectionId, tokenId, amount);1875 }18761877 /**1878 * Destroys a concrete instance of RFT on behalf of the owner.1879 * @param signer keyring of signer1880 * @param collectionId ID of collection1881 * @param tokenId ID of token1882 * @param fromAddressObj address on behalf of which the token will be burnt1883 * @param amount number of pieces to be burnt1884 * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1885 * @returns ```true``` if extrinsic success, otherwise ```false```1886 */1887 async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1888 return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1889 }18901891 /**1892 * Set, change, or remove approved address to transfer the ownership of the RFT.1893 *1894 * @param signer keyring of signer1895 * @param collectionId ID of collection1896 * @param tokenId ID of token1897 * @param toAddressObj address to approve1898 * @param amount number of pieces to be approved1899 * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);1900 * @returns true if the token success, otherwise false1901 */1902 approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1903 return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1904 }19051906 /**1907 * Get total number of pieces1908 * @param collectionId ID of collection1909 * @param tokenId ID of token1910 * @example getTokenTotalPieces(10, 5);1911 * @returns number of pieces1912 */1913 async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {1914 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();1915 }19161917 /**1918 * Change number of token pieces. Signer must be the owner of all token pieces.1919 * @param signer keyring of signer1920 * @param collectionId ID of collection1921 * @param tokenId ID of token1922 * @param amount new number of pieces1923 * @example repartitionToken(aliceKeyring, 10, 5, 12345n);1924 * @returns true if the repartion was success, otherwise false1925 */1926 async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {1927 const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);1928 const repartitionResult = await this.helper.executeExtrinsic(1929 signer,1930 'api.tx.unique.repartition', [collectionId, tokenId, amount],1931 true,1932 );1933 if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');1934 return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');1935 }1936}193719381939class FTGroup extends CollectionGroup {1940 /**1941 * Get collection object1942 * @param collectionId ID of collection1943 * @example getCollectionObject(2);1944 * @returns instance of UniqueFTCollection1945 */1946 getCollectionObject(collectionId: number): UniqueFTCollection {1947 return new UniqueFTCollection(collectionId, this.helper);1948 }19491950 /**1951 * Mint new fungible collection1952 * @param signer keyring of signer1953 * @param collectionOptions Collection options1954 * @param decimalPoints number of token decimals1955 * @example1956 * mintCollection(aliceKeyring, {1957 * name: 'New',1958 * description: 'New collection',1959 * tokenPrefix: 'NEW',1960 * }, 18)1961 * @returns newly created fungible collection1962 */1963 async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {1964 collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1965 if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');1966 collectionOptions.mode = {fungible: decimalPoints};1967 for (const key of ['name', 'description', 'tokenPrefix']) {1968 if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);1969 }1970 const creationResult = await this.helper.executeExtrinsic(1971 signer,1972 'api.tx.unique.createCollectionEx', [collectionOptions],1973 true,1974 );1975 return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1976 }19771978 /**1979 * Mint tokens1980 * @param signer keyring of signer1981 * @param collectionId ID of collection1982 * @param owner address owner of new tokens1983 * @param amount amount of tokens to be meanted1984 * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);1985 * @returns ```true``` if extrinsic success, otherwise ```false```1986 */1987 async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {1988 const creationResult = await this.helper.executeExtrinsic(1989 signer,1990 'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {1991 fungible: {1992 value: amount,1993 },1994 }],1995 true, // `Unable to mint fungible tokens for ${label}`,1996 );1997 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1998 }19992000 /**2001 * Mint multiple Fungible tokens with one owner2002 * @param signer keyring of signer2003 * @param collectionId ID of collection2004 * @param owner tokens owner2005 * @param tokens array of tokens with properties and pieces2006 * @returns ```true``` if extrinsic success, otherwise ```false```2007 */2008 async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {2009 const rawTokens = [];2010 for (const token of tokens) {2011 const raw = {Fungible: {Value: token.value}};2012 rawTokens.push(raw);2013 }2014 const creationResult = await this.helper.executeExtrinsic(2015 signer,2016 'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],2017 true,2018 );2019 return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2020 }20212022 /**2023 * Get the top 10 owners with the largest balance for the Fungible collection2024 * @param collectionId ID of collection2025 * @example getTop10Owners(10);2026 * @returns array of ```ICrossAccountId```2027 */2028 async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {2029 return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);2030 }20312032 /**2033 * Get account balance2034 * @param collectionId ID of collection2035 * @param addressObj address of owner2036 * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})2037 * @returns amount of fungible tokens owned by address2038 */2039 async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {2040 return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();2041 }20422043 /**2044 * Transfer tokens to address2045 * @param signer keyring of signer2046 * @param collectionId ID of collection2047 * @param toAddressObj address recipient2048 * @param amount amount of tokens to be sent2049 * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2050 * @returns ```true``` if extrinsic success, otherwise ```false```2051 */2052 async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2053 return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);2054 }20552056 /**2057 * Transfer some tokens on behalf of the owner.2058 * @param signer keyring of signer2059 * @param collectionId ID of collection2060 * @param fromAddressObj address on behalf of which tokens will be sent2061 * @param toAddressObj address where token to be sent2062 * @param amount number of tokens to be sent2063 * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);2064 * @returns ```true``` if extrinsic success, otherwise ```false```2065 */2066 async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2067 return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2068 }20692070 /**2071 * Destroy some amount of tokens2072 * @param signer keyring of signer2073 * @param collectionId ID of collection2074 * @param amount amount of tokens to be destroyed2075 * @example burnTokens(aliceKeyring, 10, 1000n);2076 * @returns ```true``` if extrinsic success, otherwise ```false```2077 */2078 async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {2079 return await super.burnToken(signer, collectionId, 0, amount);2080 }20812082 /**2083 * Burn some tokens on behalf of the owner.2084 * @param signer keyring of signer2085 * @param collectionId ID of collection2086 * @param fromAddressObj address on behalf of which tokens will be burnt2087 * @param amount amount of tokens to be burnt2088 * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2089 * @returns ```true``` if extrinsic success, otherwise ```false```2090 */2091 async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {2092 return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2093 }20942095 /**2096 * Get total collection supply2097 * @param collectionId2098 * @returns2099 */2100 async getTotalPieces(collectionId: number): Promise<bigint> {2101 return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2102 }21032104 /**2105 * Set, change, or remove approved address to transfer tokens.2106 *2107 * @param signer keyring of signer2108 * @param collectionId ID of collection2109 * @param toAddressObj address to be approved2110 * @param amount amount of tokens to be approved2111 * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2112 * @returns ```true``` if extrinsic success, otherwise ```false```2113 */2114 approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2115 return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2116 }21172118 /**2119 * Get amount of fungible tokens approved to transfer2120 * @param collectionId ID of collection2121 * @param fromAddressObj owner of tokens2122 * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2123 * @returns number of tokens approved for the transfer2124 */2125 getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2126 return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2127 }2128}212921302131class ChainGroup extends HelperGroup<ChainHelperBase> {2132 /**2133 * Get system properties of a chain2134 * @example getChainProperties();2135 * @returns ss58Format, token decimals, and token symbol2136 */2137 getChainProperties(): IChainProperties {2138 const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2139 return {2140 ss58Format: properties.ss58Format.toJSON(),2141 tokenDecimals: properties.tokenDecimals.toJSON(),2142 tokenSymbol: properties.tokenSymbol.toJSON(),2143 };2144 }21452146 /**2147 * Get chain header2148 * @example getLatestBlockNumber();2149 * @returns the number of the last block2150 */2151 async getLatestBlockNumber(): Promise<number> {2152 return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2153 }21542155 /**2156 * Get block hash by block number2157 * @param blockNumber number of block2158 * @example getBlockHashByNumber(12345);2159 * @returns hash of a block2160 */2161 async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2162 const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2163 if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2164 return blockHash;2165 }21662167 // TODO add docs2168 async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2169 const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2170 if (!blockHash) return null;2171 return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2172 }21732174 /**2175 * Get account nonce2176 * @param address substrate address2177 * @example getNonce("5GrwvaEF5zXb26Fz...");2178 * @returns number, account's nonce2179 */2180 async getNonce(address: TSubstrateAccount): Promise<number> {2181 return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2182 }2183}21842185class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2186 /**2187 * Get substrate address balance2188 * @param address substrate address2189 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2190 * @returns amount of tokens on address2191 */2192 async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2193 return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2194 }21952196 /**2197 * Transfer tokens to substrate address2198 * @param signer keyring of signer2199 * @param address substrate address of a recipient2200 * @param amount amount of tokens to be transfered2201 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2202 * @returns ```true``` if extrinsic success, otherwise ```false```2203 */2204 async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2205 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true/*, `Unable to transfer balance from ${this.helper.getSignerAddress(signer)} to ${address}`*/);22062207 let transfer = {from: null, to: null, amount: 0n} as any;2208 result.result.events.forEach(({event: {data, method, section}}) => {2209 if ((section === 'balances') && (method === 'Transfer')) {2210 transfer = {2211 from: this.helper.address.normalizeSubstrate(data[0]),2212 to: this.helper.address.normalizeSubstrate(data[1]),2213 amount: BigInt(data[2]),2214 };2215 }2216 });2217 const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from2218 && this.helper.address.normalizeSubstrate(address) === transfer.to2219 && BigInt(amount) === transfer.amount;2220 return isSuccess;2221 }22222223 /**2224 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2225 * @param address substrate address2226 * @returns2227 */2228 async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2229 const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2230 return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2231 }2232}22332234class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2235 /**2236 * Get ethereum address balance2237 * @param address ethereum address2238 * @example getEthereum("0x9F0583DbB855d...")2239 * @returns amount of tokens on address2240 */2241 async getEthereum(address: TEthereumAccount): Promise<bigint> {2242 return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2243 }22442245 /**2246 * Transfer tokens to address2247 * @param signer keyring of signer2248 * @param address Ethereum address of a recipient2249 * @param amount amount of tokens to be transfered2250 * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2251 * @returns ```true``` if extrinsic success, otherwise ```false```2252 */2253 async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2254 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);22552256 let transfer = {from: null, to: null, amount: 0n} as any;2257 result.result.events.forEach(({event: {data, method, section}}) => {2258 if ((section === 'balances') && (method === 'Transfer')) {2259 transfer = {2260 from: data[0].toString(),2261 to: data[1].toString(),2262 amount: BigInt(data[2]),2263 };2264 }2265 });2266 const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from2267 && address === transfer.to2268 && BigInt(amount) === transfer.amount;2269 return isSuccess;2270 }2271}22722273class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2274 subBalanceGroup: SubstrateBalanceGroup<T>;2275 ethBalanceGroup: EthereumBalanceGroup<T>;22762277 constructor(helper: T) {2278 super(helper);2279 this.subBalanceGroup = new SubstrateBalanceGroup(helper);2280 this.ethBalanceGroup = new EthereumBalanceGroup(helper);2281 }22822283 getCollectionCreationPrice(): bigint {2284 return 2n * this.getOneTokenNominal();2285 }2286 /**2287 * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2288 * @example getOneTokenNominal()2289 * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2290 */2291 getOneTokenNominal(): bigint {2292 const chainProperties = this.helper.chain.getChainProperties();2293 return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2294 }22952296 /**2297 * Get substrate address balance2298 * @param address substrate address2299 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2300 * @returns amount of tokens on address2301 */2302 getSubstrate(address: TSubstrateAccount): Promise<bigint> {2303 return this.subBalanceGroup.getSubstrate(address);2304 }23052306 /**2307 * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2308 * @param address substrate address2309 * @returns2310 */2311 getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2312 return this.subBalanceGroup.getSubstrateFull(address);2313 }23142315 /**2316 * Get ethereum address balance2317 * @param address ethereum address2318 * @example getEthereum("0x9F0583DbB855d...")2319 * @returns amount of tokens on address2320 */2321 getEthereum(address: TEthereumAccount): Promise<bigint> {2322 return this.ethBalanceGroup.getEthereum(address);2323 }23242325 /**2326 * Transfer tokens to substrate address2327 * @param signer keyring of signer2328 * @param address substrate address of a recipient2329 * @param amount amount of tokens to be transfered2330 * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2331 * @returns ```true``` if extrinsic success, otherwise ```false```2332 */2333 transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2334 return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2335 }23362337 async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2338 const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);23392340 let transfer = {from: null, to: null, amount: 0n} as any;2341 result.result.events.forEach(({event: {data, method, section}}) => {2342 if ((section === 'balances') && (method === 'Transfer')) {2343 transfer = {2344 from: this.helper.address.normalizeSubstrate(data[0]),2345 to: this.helper.address.normalizeSubstrate(data[1]),2346 amount: BigInt(data[2]),2347 };2348 }2349 });2350 let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2351 isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2352 isSuccess = isSuccess && BigInt(amount) === transfer.amount;2353 return isSuccess;2354 }2355}23562357class AddressGroup extends HelperGroup<ChainHelperBase> {2358 /**2359 * Normalizes the address to the specified ss58 format, by default ```42```.2360 * @param address substrate address2361 * @param ss58Format format for address conversion, by default ```42```2362 * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2363 * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2364 */2365 normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2366 return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2367 }23682369 /**2370 * Get address in the connected chain format2371 * @param address substrate address2372 * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2373 * @returns address in chain format2374 */2375 normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2376 return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2377 }23782379 /**2380 * Get substrate mirror of an ethereum address2381 * @param ethAddress ethereum address2382 * @param toChainFormat false for normalized account2383 * @example ethToSubstrate('0x9F0583DbB855d...')2384 * @returns substrate mirror of a provided ethereum address2385 */2386 ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2387 return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2388 }23892390 /**2391 * Get ethereum mirror of a substrate address2392 * @param subAddress substrate account2393 * @example substrateToEth("5DnSF6RRjwteE3BrC...")2394 * @returns ethereum mirror of a provided substrate address2395 */2396 substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2397 return CrossAccountId.translateSubToEth(subAddress);2398 }23992400 /**2401 * Encode key to substrate address2402 * @param key key for encoding address2403 * @param ss58Format prefix for encoding to the address of the corresponding network2404 * @returns encoded substrate address2405 */2406 encodeSubstrateAddress (key: Uint8Array | string | bigint, ss58Format = 42): string {2407 const u8a :Uint8Array = typeof key === 'string'2408 ? hexToU8a(key)2409 : typeof key === 'bigint'2410 ? hexToU8a(key.toString(16))2411 : key;2412 2413 if (ss58Format < 0 || ss58Format > 16383 || [46, 47].includes(ss58Format)) {2414 throw new Error(`ss58Format is not valid, received ${typeofss58Format} "${ss58Format}"`);2415 }2416 2417 const allowedDecodedLengths = [1, 2, 4, 8, 32, 33];2418 if (!allowedDecodedLengths.includes(u8a.length)) {2419 throw new Error(`key length is not valid, received ${u8a.length}, valid values are ${allowedDecodedLengths.join(', ')}`);2420 }2421 2422 const u8aPrefix = ss58Format < 642423 ? new Uint8Array([ss58Format])2424 : new Uint8Array([2425 ((ss58Format & 0xfc) >> 2) | 0x40,2426 (ss58Format >> 8) | ((ss58Format & 0x03) << 6),2427 ]);24282429 const input = u8aConcat(u8aPrefix, u8a);2430 2431 return base58Encode(u8aConcat(2432 input,2433 blake2AsU8a(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1),2434 ));2435 }24362437 /**2438 * Restore substrate address from bigint representation2439 * @param number decimal representation of substrate address2440 * @returns substrate address2441 */2442 restoreCrossAccountFromBigInt(number: bigint): TSubstrateAccount {2443 if (this.helper.api === null) {2444 throw 'Not connected';2445 }2446 const res = this.helper.api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();2447 if (res === undefined || res === null) {2448 throw 'Restore address error';2449 }2450 return res.toString();2451 }24522453 /**2454 * Convert etherium cross account id to substrate cross account id2455 * @param ethCrossAccount etherium cross account2456 * @returns substrate cross account id2457 */2458 convertCrossAccountFromEthCrossAccount(ethCrossAccount: IEthCrossAccountId): ICrossAccountId {2459 if (ethCrossAccount.sub === '0') {2460 return {Ethereum: ethCrossAccount.eth.toLocaleLowerCase()};2461 }2462 2463 const ss58 = this.restoreCrossAccountFromBigInt(BigInt(ethCrossAccount.sub));2464 return {Substrate: ss58};2465 }24662467 paraSiblingSovereignAccount(paraid: number) {2468 // We are getting a *sibling* parachain sovereign account,2469 // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c2470 const siblingPrefix = '0x7369626c';24712472 const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2473 const suffix = '000000000000000000000000000000000000000000000000';24742475 return siblingPrefix + encodedParaId + suffix;2476 }2477}24782479class StakingGroup extends HelperGroup<UniqueHelper> {2480 /**2481 * Stake tokens for App Promotion2482 * @param signer keyring of signer2483 * @param amountToStake amount of tokens to stake2484 * @param label extra label for log2485 * @returns2486 */2487 async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2488 if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2489 const _stakeResult = await this.helper.executeExtrinsic(2490 signer, 'api.tx.appPromotion.stake',2491 [amountToStake], true,2492 );2493 // TODO extract info from stakeResult2494 return true;2495 }24962497 /**2498 * Unstake tokens for App Promotion2499 * @param signer keyring of signer2500 * @param amountToUnstake amount of tokens to unstake2501 * @param label extra label for log2502 * @returns block number where balances will be unlocked2503 */2504 async unstake(signer: TSigner, label?: string): Promise<number> {2505 if(typeof label === 'undefined') label = `${signer.address}`;2506 const _unstakeResult = await this.helper.executeExtrinsic(2507 signer, 'api.tx.appPromotion.unstake',2508 [], true,2509 );2510 // TODO extract block number fron events2511 return 1;2512 }25132514 /**2515 * Get total staked amount for address2516 * @param address substrate or ethereum address2517 * @returns total staked amount2518 */2519 async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2520 if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2521 return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2522 }25232524 /**2525 * Get total staked per block2526 * @param address substrate or ethereum address2527 * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2528 */2529 async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2530 const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2531 return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2532 return {2533 block: block.toBigInt(),2534 amount: amount.toBigInt(),2535 };2536 });2537 }25382539 /**2540 * Get total pending unstake amount for address2541 * @param address substrate or ethereum address2542 * @returns total pending unstake amount2543 */2544 async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2545 return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2546 }25472548 /**2549 * Get pending unstake amount per block for address2550 * @param address substrate or ethereum address2551 * @returns array of pending stakes. `block` – the number of the block in which the unstake was made. `amount` - the number of tokens unstaked in the block2552 */2553 async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2554 const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2555 const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2556 return {2557 block: block.toBigInt(),2558 amount: amount.toBigInt(),2559 };2560 });2561 return result;2562 }2563}25642565class SchedulerGroup extends HelperGroup<UniqueHelper> {2566 constructor(helper: UniqueHelper) {2567 super(helper);2568 }25692570 cancelScheduled(signer: TSigner, scheduledId: string) {2571 return this.helper.executeExtrinsic(2572 signer,2573 'api.tx.scheduler.cancelNamed',2574 [scheduledId],2575 true,2576 );2577 }25782579 changePriority(signer: TSigner, scheduledId: string, priority: number) {2580 return this.helper.executeExtrinsic(2581 signer,2582 'api.tx.scheduler.changeNamedPriority',2583 [scheduledId, priority],2584 true,2585 );2586 }25872588 scheduleAt<T extends UniqueHelper>(2589 executionBlockNumber: number,2590 options: ISchedulerOptions = {},2591 ) {2592 return this.schedule<T>('schedule', executionBlockNumber, options);2593 }25942595 scheduleAfter<T extends UniqueHelper>(2596 blocksBeforeExecution: number,2597 options: ISchedulerOptions = {},2598 ) {2599 return this.schedule<T>('scheduleAfter', blocksBeforeExecution, options);2600 }26012602 schedule<T extends UniqueHelper>(2603 scheduleFn: 'schedule' | 'scheduleAfter',2604 blocksNum: number,2605 options: ISchedulerOptions = {},2606 ) {2607 // eslint-disable-next-line @typescript-eslint/naming-convention2608 const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2609 return this.helper.clone(ScheduledHelperType, {2610 scheduleFn,2611 blocksNum,2612 options,2613 }) as T;2614 }2615}26162617class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2618 async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2619 await this.helper.executeExtrinsic(2620 signer,2621 'api.tx.foreignAssets.registerForeignAsset',2622 [ownerAddress, location, metadata],2623 true,2624 );2625 }26262627 async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2628 await this.helper.executeExtrinsic(2629 signer,2630 'api.tx.foreignAssets.updateForeignAsset',2631 [foreignAssetId, location, metadata],2632 true,2633 );2634 }2635}26362637class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2638 palletName: string;26392640 constructor(helper: T, palletName: string) {2641 super(helper);26422643 this.palletName = palletName;2644 }26452646 async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: number) {2647 await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, {Limited: weightLimit}], true);2648 }2649}26502651class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2652 async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: number) {2653 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);2654 }26552656 async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: number) {2657 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);2658 }26592660 async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: number) {2661 await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);2662 }2663}26642665class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2666 async accounts(address: string, currencyId: any) {2667 const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;2668 return BigInt(free);2669 }2670}26712672class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {2673 async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {2674 await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);2675 }26762677 async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {2678 await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);2679 }26802681 async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {2682 await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);2683 }26842685 async account(assetId: string | number, address: string) {2686 const accountAsset = (2687 await this.helper.callRpc('api.query.assets.account', [assetId, address])2688 ).toJSON()! as any;26892690 if (accountAsset !== null) {2691 return BigInt(accountAsset['balance']);2692 } else {2693 return null;2694 }2695 }2696}26972698class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {2699 async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {2700 await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);2701 }2702}27032704class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {2705 makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {2706 const apiPrefix = 'api.tx.assetManager.';27072708 const registerTx = this.helper.constructApiCall(2709 apiPrefix + 'registerForeignAsset',2710 [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],2711 );27122713 const setUnitsTx = this.helper.constructApiCall(2714 apiPrefix + 'setAssetUnitsPerSecond',2715 [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],2716 );27172718 const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);2719 const encodedProposal = batchCall?.method.toHex() || '';2720 return encodedProposal;2721 }27222723 async assetTypeId(location: any) {2724 return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);2725 }2726}27272728class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {2729 async notePreimage(signer: TSigner, encodedProposal: string) {2730 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.notePreimage', [encodedProposal], true);2731 }27322733 externalProposeMajority(proposalHash: string) {2734 return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposalHash]);2735 }27362737 fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {2738 return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);2739 }27402741 async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {2742 await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);2743 }2744}27452746class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {2747 collective: string;27482749 constructor(helper: MoonbeamHelper, collective: string) {2750 super(helper);27512752 this.collective = collective;2753 }27542755 async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {2756 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);2757 }27582759 async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {2760 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);2761 }27622763 async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: number, lengthBound: number) {2764 await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);2765 }27662767 async proposalCount() {2768 return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));2769 }2770}27712772export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;2773export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;27742775export class UniqueHelper extends ChainHelperBase {2776 balance: BalanceGroup<UniqueHelper>;2777 collection: CollectionGroup;2778 nft: NFTGroup;2779 rft: RFTGroup;2780 ft: FTGroup;2781 staking: StakingGroup;2782 scheduler: SchedulerGroup;2783 foreignAssets: ForeignAssetsGroup;2784 xcm: XcmGroup<UniqueHelper>;2785 xTokens: XTokensGroup<UniqueHelper>;2786 tokens: TokensGroup<UniqueHelper>;27872788 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2789 super(logger, options.helperBase ?? UniqueHelper);27902791 this.balance = new BalanceGroup(this);2792 this.collection = new CollectionGroup(this);2793 this.nft = new NFTGroup(this);2794 this.rft = new RFTGroup(this);2795 this.ft = new FTGroup(this);2796 this.staking = new StakingGroup(this);2797 this.scheduler = new SchedulerGroup(this);2798 this.foreignAssets = new ForeignAssetsGroup(this);2799 this.xcm = new XcmGroup(this, 'polkadotXcm');2800 this.xTokens = new XTokensGroup(this);2801 this.tokens = new TokensGroup(this);2802 }28032804 getSudo<T extends UniqueHelper>() {2805 // eslint-disable-next-line @typescript-eslint/naming-convention2806 const SudoHelperType = SudoHelper(this.helperBase);2807 return this.clone(SudoHelperType) as T;2808 }2809}28102811export class XcmChainHelper extends ChainHelperBase {2812 async connect(wsEndpoint: string, _listeners?: any): Promise<void> {2813 const wsProvider = new WsProvider(wsEndpoint);2814 this.api = new ApiPromise({2815 provider: wsProvider,2816 });2817 await this.api.isReadyOrError;2818 this.network = await UniqueHelper.detectNetwork(this.api);2819 }2820}28212822export class RelayHelper extends XcmChainHelper {2823 xcm: XcmGroup<RelayHelper>;28242825 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2826 super(logger, options.helperBase ?? RelayHelper);28272828 this.xcm = new XcmGroup(this, 'xcmPallet');2829 }2830}28312832export class WestmintHelper extends XcmChainHelper {2833 balance: SubstrateBalanceGroup<WestmintHelper>;2834 xcm: XcmGroup<WestmintHelper>;2835 assets: AssetsGroup<WestmintHelper>;2836 xTokens: XTokensGroup<WestmintHelper>;28372838 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2839 super(logger, options.helperBase ?? WestmintHelper);28402841 this.balance = new SubstrateBalanceGroup(this);2842 this.xcm = new XcmGroup(this, 'polkadotXcm');2843 this.assets = new AssetsGroup(this);2844 this.xTokens = new XTokensGroup(this);2845 }2846}28472848export class MoonbeamHelper extends XcmChainHelper {2849 balance: EthereumBalanceGroup<MoonbeamHelper>;2850 assetManager: MoonbeamAssetManagerGroup;2851 assets: AssetsGroup<MoonbeamHelper>;2852 xTokens: XTokensGroup<MoonbeamHelper>;2853 democracy: MoonbeamDemocracyGroup;2854 collective: {2855 council: MoonbeamCollectiveGroup,2856 techCommittee: MoonbeamCollectiveGroup,2857 };28582859 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2860 super(logger, options.helperBase ?? MoonbeamHelper);28612862 this.balance = new EthereumBalanceGroup(this);2863 this.assetManager = new MoonbeamAssetManagerGroup(this);2864 this.assets = new AssetsGroup(this);2865 this.xTokens = new XTokensGroup(this);2866 this.democracy = new MoonbeamDemocracyGroup(this);2867 this.collective = {2868 council: new MoonbeamCollectiveGroup(this, 'councilCollective'),2869 techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),2870 };2871 }2872}28732874export class AcalaHelper extends XcmChainHelper {2875 balance: SubstrateBalanceGroup<AcalaHelper>;2876 assetRegistry: AcalaAssetRegistryGroup;2877 xTokens: XTokensGroup<AcalaHelper>;2878 tokens: TokensGroup<AcalaHelper>;28792880 constructor(logger?: ILogger, options: {[key: string]: any} = {}) {2881 super(logger, options.helperBase ?? AcalaHelper);28822883 this.balance = new SubstrateBalanceGroup(this);2884 this.assetRegistry = new AcalaAssetRegistryGroup(this);2885 this.xTokens = new XTokensGroup(this);2886 this.tokens = new TokensGroup(this);2887 }28882889 getSudo<T extends AcalaHelper>() {2890 // eslint-disable-next-line @typescript-eslint/naming-convention2891 const SudoHelperType = SudoHelper(this.helperBase);2892 return this.clone(SudoHelperType) as T;2893 }2894}28952896// eslint-disable-next-line @typescript-eslint/naming-convention2897function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {2898 return class extends Base {2899 scheduleFn: 'schedule' | 'scheduleAfter';2900 blocksNum: number;2901 options: ISchedulerOptions;29022903 constructor(...args: any[]) {2904 const logger = args[0] as ILogger;2905 const options = args[1] as {2906 scheduleFn: 'schedule' | 'scheduleAfter',2907 blocksNum: number,2908 options: ISchedulerOptions2909 };29102911 super(logger);29122913 this.scheduleFn = options.scheduleFn;2914 this.blocksNum = options.blocksNum;2915 this.options = options.options;2916 }29172918 executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {2919 const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);2920 2921 const mandatorySchedArgs = [2922 this.blocksNum,2923 this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,2924 this.options.priority ?? null,2925 scheduledTx,2926 ];2927 2928 let schedArgs;2929 let scheduleFn;29302931 if (this.options.scheduledId) {2932 schedArgs = [this.options.scheduledId!, ...mandatorySchedArgs];29332934 if (this.scheduleFn == 'schedule') {2935 scheduleFn = 'scheduleNamed';2936 } else if (this.scheduleFn == 'scheduleAfter') {2937 scheduleFn = 'scheduleNamedAfter';2938 }2939 } else {2940 schedArgs = mandatorySchedArgs;2941 scheduleFn = this.scheduleFn;2942 }29432944 const extrinsic = 'api.tx.scheduler.' + scheduleFn;29452946 return super.executeExtrinsic(2947 sender,2948 extrinsic,2949 schedArgs,2950 expectSuccess,2951 );2952 }2953 };2954}29552956// eslint-disable-next-line @typescript-eslint/naming-convention2957function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {2958 return class extends Base {2959 constructor(...args: any[]) {2960 super(...args);2961 }29622963 executeExtrinsic (2964 sender: IKeyringPair,2965 extrinsic: string,2966 params: any[],2967 expectSuccess?: boolean,2968 ): Promise<ITransactionResult> {2969 const call = this.constructApiCall(extrinsic, params);2970 return super.executeExtrinsic(2971 sender,2972 'api.tx.sudo.sudo',2973 [call],2974 expectSuccess,2975 );2976 }2977 };2978}29792980export class UniqueBaseCollection {2981 helper: UniqueHelper;2982 collectionId: number;29832984 constructor(collectionId: number, uniqueHelper: UniqueHelper) {2985 this.collectionId = collectionId;2986 this.helper = uniqueHelper;2987 }29882989 async getData() {2990 return await this.helper.collection.getData(this.collectionId);2991 }29922993 async getLastTokenId() {2994 return await this.helper.collection.getLastTokenId(this.collectionId);2995 }29962997 async doesTokenExist(tokenId: number) {2998 return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);2999 }30003001 async getAdmins() {3002 return await this.helper.collection.getAdmins(this.collectionId);3003 }30043005 async getAllowList() {3006 return await this.helper.collection.getAllowList(this.collectionId);3007 }30083009 async getEffectiveLimits() {3010 return await this.helper.collection.getEffectiveLimits(this.collectionId);3011 }30123013 async getProperties(propertyKeys?: string[] | null) {3014 return await this.helper.collection.getProperties(this.collectionId, propertyKeys);3015 }30163017 async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {3018 return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);3019 }30203021 async getOptions() {3022 return await this.helper.collection.getCollectionOptions(this.collectionId);3023 }30243025 async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {3026 return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);3027 }30283029 async confirmSponsorship(signer: TSigner) {3030 return await this.helper.collection.confirmSponsorship(signer, this.collectionId);3031 }30323033 async removeSponsor(signer: TSigner) {3034 return await this.helper.collection.removeSponsor(signer, this.collectionId);3035 }30363037 async setLimits(signer: TSigner, limits: ICollectionLimits) {3038 return await this.helper.collection.setLimits(signer, this.collectionId, limits);3039 }30403041 async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {3042 return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);3043 }30443045 async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3046 return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);3047 }30483049 async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {3050 return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);3051 }30523053 async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {3054 return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);3055 }30563057 async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3058 return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);3059 }30603061 async setProperties(signer: TSigner, properties: IProperty[]) {3062 return await this.helper.collection.setProperties(signer, this.collectionId, properties);3063 }30643065 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3066 return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);3067 }30683069 async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {3070 return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);3071 }30723073 async enableNesting(signer: TSigner, permissions: INestingPermissions) {3074 return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);3075 }30763077 async disableNesting(signer: TSigner) {3078 return await this.helper.collection.disableNesting(signer, this.collectionId);3079 }30803081 async burn(signer: TSigner) {3082 return await this.helper.collection.burn(signer, this.collectionId);3083 }30843085 scheduleAt<T extends UniqueHelper>(3086 executionBlockNumber: number,3087 options: ISchedulerOptions = {},3088 ) {3089 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3090 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3091 }30923093 scheduleAfter<T extends UniqueHelper>(3094 blocksBeforeExecution: number,3095 options: ISchedulerOptions = {},3096 ) {3097 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3098 return new UniqueBaseCollection(this.collectionId, scheduledHelper);3099 }31003101 getSudo<T extends UniqueHelper>() {3102 return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());3103 }3104}310531063107export class UniqueNFTCollection extends UniqueBaseCollection {3108 getTokenObject(tokenId: number) {3109 return new UniqueNFToken(tokenId, this);3110 }31113112 async getTokensByAddress(addressObj: ICrossAccountId) {3113 return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);3114 }31153116 async getToken(tokenId: number, blockHashAt?: string) {3117 return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);3118 }31193120 async getTokenOwner(tokenId: number, blockHashAt?: string) {3121 return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3122 }31233124 async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3125 return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3126 }31273128 async getTokenChildren(tokenId: number, blockHashAt?: string) {3129 return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);3130 }31313132 async getPropertyPermissions(propertyKeys: string[] | null = null) {3133 return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);3134 }31353136 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3137 return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3138 }31393140 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {3141 return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);3142 }31433144 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3145 return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);3146 }31473148 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {3149 return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);3150 }31513152 async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {3153 return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);3154 }31553156 async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3157 return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});3158 }31593160 async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {3161 return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);3162 }31633164 async burnToken(signer: TSigner, tokenId: number) {3165 return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);3166 }31673168 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {3169 return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);3170 }31713172 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3173 return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);3174 }31753176 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3177 return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3178 }31793180 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3181 return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3182 }31833184 async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3185 return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3186 }31873188 async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3189 return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3190 }31913192 scheduleAt<T extends UniqueHelper>(3193 executionBlockNumber: number,3194 options: ISchedulerOptions = {},3195 ) {3196 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3197 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3198 }31993200 scheduleAfter<T extends UniqueHelper>(3201 blocksBeforeExecution: number,3202 options: ISchedulerOptions = {},3203 ) {3204 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3205 return new UniqueNFTCollection(this.collectionId, scheduledHelper);3206 }32073208 getSudo<T extends UniqueHelper>() {3209 return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());3210 }3211}321232133214export class UniqueRFTCollection extends UniqueBaseCollection {3215 getTokenObject(tokenId: number) {3216 return new UniqueRFToken(tokenId, this);3217 }32183219 async getToken(tokenId: number, blockHashAt?: string) {3220 return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);3221 }32223223 async getTokensByAddress(addressObj: ICrossAccountId) {3224 return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);3225 }32263227 async getTop10TokenOwners(tokenId: number) {3228 return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);3229 }32303231 async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {3232 return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3233 }32343235 async getTokenTotalPieces(tokenId: number) {3236 return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3237 }32383239 async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3240 return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3241 }32423243 async getPropertyPermissions(propertyKeys: string[] | null = null) {3244 return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3245 }32463247 async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3248 return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3249 }32503251 async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3252 return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3253 }32543255 async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3256 return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3257 }32583259 async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3260 return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3261 }32623263 async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3264 return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3265 }32663267 async mintToken(signer: TSigner, pieces=1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3268 return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3269 }32703271 async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3272 return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3273 }32743275 async burnToken(signer: TSigner, tokenId: number, amount=1n) {3276 return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3277 }32783279 async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n) {3280 return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3281 }32823283 async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3284 return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3285 }32863287 async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3288 return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3289 }32903291 async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3292 return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3293 }32943295 scheduleAt<T extends UniqueHelper>(3296 executionBlockNumber: number,3297 options: ISchedulerOptions = {},3298 ) {3299 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3300 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3301 }33023303 scheduleAfter<T extends UniqueHelper>(3304 blocksBeforeExecution: number,3305 options: ISchedulerOptions = {},3306 ) {3307 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3308 return new UniqueRFTCollection(this.collectionId, scheduledHelper);3309 }33103311 getSudo<T extends UniqueHelper>() {3312 return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3313 }3314}331533163317export class UniqueFTCollection extends UniqueBaseCollection {3318 async getBalance(addressObj: ICrossAccountId) {3319 return await this.helper.ft.getBalance(this.collectionId, addressObj);3320 }33213322 async getTotalPieces() {3323 return await this.helper.ft.getTotalPieces(this.collectionId);3324 }33253326 async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3327 return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3328 }33293330 async getTop10Owners() {3331 return await this.helper.ft.getTop10Owners(this.collectionId);3332 }33333334 async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3335 return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3336 }33373338 async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3339 return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3340 }33413342 async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3343 return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3344 }33453346 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3347 return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3348 }33493350 async burnTokens(signer: TSigner, amount=1n) {3351 return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3352 }33533354 async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3355 return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3356 }33573358 async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3359 return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3360 }33613362 scheduleAt<T extends UniqueHelper>(3363 executionBlockNumber: number,3364 options: ISchedulerOptions = {},3365 ) {3366 const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3367 return new UniqueFTCollection(this.collectionId, scheduledHelper);3368 }33693370 scheduleAfter<T extends UniqueHelper>(3371 blocksBeforeExecution: number,3372 options: ISchedulerOptions = {},3373 ) {3374 const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3375 return new UniqueFTCollection(this.collectionId, scheduledHelper);3376 }33773378 getSudo<T extends UniqueHelper>() {3379 return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3380 }3381}338233833384export class UniqueBaseToken {3385 collection: UniqueNFTCollection | UniqueRFTCollection;3386 collectionId: number;3387 tokenId: number;33883389 constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3390 this.collection = collection;3391 this.collectionId = collection.collectionId;3392 this.tokenId = tokenId;3393 }33943395 async getNextSponsored(addressObj: ICrossAccountId) {3396 return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3397 }33983399 async getProperties(propertyKeys?: string[] | null) {3400 return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3401 }34023403 async setProperties(signer: TSigner, properties: IProperty[]) {3404 return await this.collection.setTokenProperties(signer, this.tokenId, properties);3405 }34063407 async deleteProperties(signer: TSigner, propertyKeys: string[]) {3408 return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3409 }34103411 async doesExist() {3412 return await this.collection.doesTokenExist(this.tokenId);3413 }34143415 nestingAccount() {3416 return this.collection.helper.util.getTokenAccount(this);3417 }34183419 scheduleAt<T extends UniqueHelper>(3420 executionBlockNumber: number,3421 options: ISchedulerOptions = {},3422 ) {3423 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3424 return new UniqueBaseToken(this.tokenId, scheduledCollection);3425 }34263427 scheduleAfter<T extends UniqueHelper>(3428 blocksBeforeExecution: number,3429 options: ISchedulerOptions = {},3430 ) {3431 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3432 return new UniqueBaseToken(this.tokenId, scheduledCollection);3433 }34343435 getSudo<T extends UniqueHelper>() {3436 return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3437 }3438}343934403441export class UniqueNFToken extends UniqueBaseToken {3442 collection: UniqueNFTCollection;34433444 constructor(tokenId: number, collection: UniqueNFTCollection) {3445 super(tokenId, collection);3446 this.collection = collection;3447 }34483449 async getData(blockHashAt?: string) {3450 return await this.collection.getToken(this.tokenId, blockHashAt);3451 }34523453 async getOwner(blockHashAt?: string) {3454 return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3455 }34563457 async getTopmostOwner(blockHashAt?: string) {3458 return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3459 }34603461 async getChildren(blockHashAt?: string) {3462 return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3463 }34643465 async nest(signer: TSigner, toTokenObj: IToken) {3466 return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3467 }34683469 async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3470 return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3471 }34723473 async transfer(signer: TSigner, addressObj: ICrossAccountId) {3474 return await this.collection.transferToken(signer, this.tokenId, addressObj);3475 }34763477 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3478 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3479 }34803481 async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3482 return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3483 }34843485 async isApproved(toAddressObj: ICrossAccountId) {3486 return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3487 }34883489 async burn(signer: TSigner) {3490 return await this.collection.burnToken(signer, this.tokenId);3491 }34923493 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3494 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3495 }34963497 scheduleAt<T extends UniqueHelper>(3498 executionBlockNumber: number,3499 options: ISchedulerOptions = {},3500 ) {3501 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3502 return new UniqueNFToken(this.tokenId, scheduledCollection);3503 }35043505 scheduleAfter<T extends UniqueHelper>(3506 blocksBeforeExecution: number,3507 options: ISchedulerOptions = {},3508 ) {3509 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3510 return new UniqueNFToken(this.tokenId, scheduledCollection);3511 }35123513 getSudo<T extends UniqueHelper>() {3514 return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3515 }3516}35173518export class UniqueRFToken extends UniqueBaseToken {3519 collection: UniqueRFTCollection;35203521 constructor(tokenId: number, collection: UniqueRFTCollection) {3522 super(tokenId, collection);3523 this.collection = collection;3524 }35253526 async getData(blockHashAt?: string) {3527 return await this.collection.getToken(this.tokenId, blockHashAt);3528 }35293530 async getTop10Owners() {3531 return await this.collection.getTop10TokenOwners(this.tokenId);3532 }35333534 async getBalance(addressObj: ICrossAccountId) {3535 return await this.collection.getTokenBalance(this.tokenId, addressObj);3536 }35373538 async getTotalPieces() {3539 return await this.collection.getTokenTotalPieces(this.tokenId);3540 }35413542 async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {3543 return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);3544 }35453546 async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {3547 return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);3548 }35493550 async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3551 return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);3552 }35533554 async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3555 return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);3556 }35573558 async repartition(signer: TSigner, amount: bigint) {3559 return await this.collection.repartitionToken(signer, this.tokenId, amount);3560 }35613562 async burn(signer: TSigner, amount=1n) {3563 return await this.collection.burnToken(signer, this.tokenId, amount);3564 }35653566 async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3567 return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);3568 }35693570 scheduleAt<T extends UniqueHelper>(3571 executionBlockNumber: number,3572 options: ISchedulerOptions = {},3573 ) {3574 const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3575 return new UniqueRFToken(this.tokenId, scheduledCollection);3576 }35773578 scheduleAfter<T extends UniqueHelper>(3579 blocksBeforeExecution: number,3580 options: ISchedulerOptions = {},3581 ) {3582 const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3583 return new UniqueRFToken(this.tokenId, scheduledCollection);3584 }35853586 getSudo<T extends UniqueHelper>() {3587 return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());3588 }3589}