diff --git a/tools/interactor-system-func-calls/sys-func-calls/interact/src/basic_interact.rs b/tools/interactor-system-func-calls/sys-func-calls/interact/src/basic_interact.rs index a1b3324d01..023875cd40 100644 --- a/tools/interactor-system-func-calls/sys-func-calls/interact/src/basic_interact.rs +++ b/tools/interactor-system-func-calls/sys-func-calls/interact/src/basic_interact.rs @@ -7,7 +7,7 @@ use basic_interact_config::Config; use basic_interact_state::State; use clap::Parser; -use multiversx_sc_snippets::{hex, imports::*}; +use multiversx_sc_snippets::imports::*; #[tokio::main] async fn main() { @@ -44,6 +44,58 @@ async fn main() { .burn_token(&args.token_id, args.amount.clone()) .await; }, + Some(basic_interact_cli::InteractCliCommand::PauseToken(args)) => { + basic_interact.pause_token(&args.token_id).await; + }, + Some(basic_interact_cli::InteractCliCommand::UnpauseToken(args)) => { + basic_interact.unpause_token(&args.token_id).await; + }, + Some(basic_interact_cli::InteractCliCommand::FreezeToken(args)) => { + basic_interact + .freeze_token(&args.token_id, &args.address) + .await; + }, + Some(basic_interact_cli::InteractCliCommand::UnfreezeToken(args)) => { + basic_interact + .unfreeze_token(&args.token_id, &args.address) + .await; + }, + Some(basic_interact_cli::InteractCliCommand::FreezeNFT(args)) => { + basic_interact + .freeze_nft(&args.token_id, args.nft_nonce, &args.address) + .await; + }, + Some(basic_interact_cli::InteractCliCommand::UnfreezeNFT(args)) => { + basic_interact + .unfreeze_nft(&args.token_id, args.nft_nonce, &args.address) + .await; + }, + Some(basic_interact_cli::InteractCliCommand::WipeToken(args)) => { + basic_interact + .wipe_token(&args.token_id, &args.address) + .await; + }, + Some(basic_interact_cli::InteractCliCommand::WipeNFT(args)) => { + basic_interact + .wipe_nft(&args.token_id, args.nft_nonce, &args.address) + .await; + }, + Some(basic_interact_cli::InteractCliCommand::IssueNFT(args)) => { + basic_interact + .issue_non_fungible_token(args.cost.clone(), &args.display_name, &args.ticker) + .await; + }, + Some(basic_interact_cli::InteractCliCommand::CreateNFT(args)) => { + basic_interact + .create_nft( + &args.token_id, + args.amount.clone(), + &args.name, + args.royalties, + &args.hash, + ) + .await; + }, Some(basic_interact_cli::InteractCliCommand::IssueFungible(args)) => { basic_interact ._issue_fungible_token( @@ -148,7 +200,7 @@ impl SysFuncCallsInteract { &token_ticker.into(), &initial_supply.into(), FungibleTokenProperties { - num_decimals: num_decimals, + num_decimals, can_freeze: true, can_wipe: true, can_pause: true, @@ -164,6 +216,37 @@ impl SysFuncCallsInteract { .await; } + async fn issue_non_fungible_token( + &mut self, + issue_cost: RustBigUint, + token_display_name: &str, + token_ticker: &str, + ) { + self.interactor + .tx() + .from(&self.wallet_address) + .to(ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .issue_non_fungible( + issue_cost.into(), + &token_display_name.into(), + &token_ticker.into(), + NonFungibleTokenProperties { + can_freeze: true, + can_wipe: true, + can_pause: true, + can_transfer_create_role: true, + can_change_owner: true, + can_upgrade: true, + can_add_special_roles: true, + }, + ) + .prepare_async() + .run() + .await; + } + async fn issue_semi_fungible_token( &mut self, issue_cost: RustBigUint, @@ -227,8 +310,7 @@ impl SysFuncCallsInteract { async fn set_role(&mut self, token_id: &str, roles: Vec) { let wallet_address = &self.wallet_address.clone().into_address(); - let converted_roles: Vec = - roles.into_iter().map(|r| EsdtLocalRole::from(r)).collect(); + let converted_roles: Vec = roles.into_iter().map(EsdtLocalRole::from).collect(); println!("ROLES: {:?}", converted_roles); @@ -298,7 +380,7 @@ impl SysFuncCallsInteract { &token_display_name.into(), &token_ticker.into(), MetaTokenProperties { - num_decimals: num_decimals, + num_decimals, can_freeze: true, can_wipe: true, can_transfer_create_role: true, @@ -355,9 +437,168 @@ impl SysFuncCallsInteract { .await; } + async fn pause_token(&mut self, token_id: &str) { + self.interactor + .tx() + .from(&self.wallet_address) + .to(ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .pause(&TokenIdentifier::from(token_id)) + .prepare_async() + .run() + .await; + } + + async fn unpause_token(&mut self, token_id: &str) { + self.interactor + .tx() + .from(&self.wallet_address) + .to(ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .unpause(&TokenIdentifier::from(token_id)) + .prepare_async() + .run() + .await; + } + + async fn freeze_token(&mut self, token_id: &str, address: &str) { + let address = Bech32Address::from_bech32_string(address.to_string()).to_address(); + let managed_address: ManagedAddress = ManagedAddress::from_address(&address); + self.interactor + .tx() + .from(&self.wallet_address) + .to(ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .freeze(&TokenIdentifier::from(token_id), &managed_address) + .prepare_async() + .run() + .await; + } + + async fn unfreeze_token(&mut self, token_id: &str, address: &str) { + let address = Bech32Address::from_bech32_string(address.to_string()).to_address(); + let managed_address: ManagedAddress = ManagedAddress::from_address(&address); + self.interactor + .tx() + .from(&self.wallet_address) + .to(ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .unfreeze(&TokenIdentifier::from(token_id), &managed_address) + .prepare_async() + .run() + .await; + } + + async fn freeze_nft(&mut self, token_id: &str, nonce: u64, address: &str) { + let address = Bech32Address::from_bech32_string(address.to_string()).to_address(); + let managed_address: ManagedAddress = ManagedAddress::from_address(&address); + self.interactor + .tx() + .from(&self.wallet_address) + .to(ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .freeze_nft( + &TokenIdentifier::from(token_id), + nonce, + &managed_address, + ) + .prepare_async() + .run() + .await; + } + + async fn unfreeze_nft(&mut self, token_id: &str, nonce: u64, address: &str) { + let address = Bech32Address::from_bech32_string(address.to_string()).to_address(); + let managed_address: ManagedAddress = ManagedAddress::from_address(&address); + self.interactor + .tx() + .from(&self.wallet_address) + .to(ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .unfreeze_nft( + &TokenIdentifier::from(token_id), + nonce, + &managed_address, + ) + .prepare_async() + .run() + .await; + } + + async fn wipe_token(&mut self, token_id: &str, address: &str) { + let address = Bech32Address::from_bech32_string(address.to_string()).to_address(); + let managed_address: ManagedAddress = ManagedAddress::from_address(&address); + self.interactor + .tx() + .from(&self.wallet_address) + .to(&ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .wipe(&TokenIdentifier::from(token_id), &managed_address) + .prepare_async() + .run() + .await; + } + + async fn wipe_nft(&mut self, token_id: &str, nonce: u64, address: &str) { + let address = Bech32Address::from_bech32_string(address.to_string()).to_address(); + let managed_address: ManagedAddress = ManagedAddress::from_address(&address); + self.interactor + .tx() + .from(&self.wallet_address) + .to(ESDTSystemSCAddress.to_managed_address()) + .gas(100_000_000u64) + .typed(ESDTSystemSCProxy) + .wipe_nft( + &TokenIdentifier::from(token_id), + nonce, + &managed_address, + ) + .prepare_async() + .run() + .await; + } + + async fn create_nft( + &mut self, + token_id: &str, + amount: RustBigUint, + name: &str, + royalties: u64, + hash: &str, + ) { + self.interactor + .tx() + .from(&self.wallet_address) + .to(&self.wallet_address) + .gas(100_000_000u64) + .typed(UserBuiltinProxy) + .esdt_nft_create( + &TokenIdentifier::from(token_id), + &BigUint::from(amount), + &ManagedBuffer::from(name), + &BigUint::from(royalties), + &ManagedBuffer::from(hash), + &NftDummyAttributes { + creation_epoch: 2104, + cool_factor: 5, + }, + &ManagedVec::new(), + ) + .prepare_async() + .run() + .await; + } + async fn unset_roles(&mut self, address: &str, token_id: &str, roles: Vec) { - let converted_roles: Vec = - roles.into_iter().map(|r| EsdtLocalRole::from(r)).collect(); + let converted_roles: Vec = roles.into_iter().map(EsdtLocalRole::from).collect(); + println!("ROLES: {:?}", converted_roles); diff --git a/tools/interactor-system-func-calls/sys-func-calls/interact/src/basic_interact_cli.rs b/tools/interactor-system-func-calls/sys-func-calls/interact/src/basic_interact_cli.rs index eaca398af6..f740ff3d30 100644 --- a/tools/interactor-system-func-calls/sys-func-calls/interact/src/basic_interact_cli.rs +++ b/tools/interactor-system-func-calls/sys-func-calls/interact/src/basic_interact_cli.rs @@ -21,6 +21,26 @@ pub enum InteractCliCommand { SetRoles(SetRolesArgs), #[command(name = "burn", about = "Burns fungible tokens")] Burn(BurnArgs), + #[command(name = "pause-token", about = "Pauses a fungible token")] + PauseToken(PauseTokenArgs), + #[command(name = "unpause-token", about = "Unpauses a fungible token")] + UnpauseToken(PauseTokenArgs), + #[command(name = "freeze-token", about = "Freezes a fungible token for an address")] + FreezeToken(FreezeTokenArgs), + #[command(name = "unfreeze-token", about = "Unfreezes a fungible token for an address")] + UnfreezeToken(FreezeTokenArgs), + #[command(name = "freeze-nft", about = "Freezes a non-fungible token for an address")] + FreezeNFT(FreezeNFTArgs), + #[command(name = "unfreeze-nft", about = "Unfreezes a non-fungible token for an address")] + UnfreezeNFT(FreezeNFTArgs), + #[command(name = "wipe-token", about = "Wipes a fungible token for an address")] + WipeToken(WipeTokenArgs), + #[command(name = "wipe-nft", about = "Freezes a non-fungible token for an address")] + WipeNFT(WipeNFTArgs), + #[command(name = "issue-non-fungible-token", about = "Create a NFT Collection")] + IssueNFT(IssueNFTArgs), + #[command(name = "create-nft", about = "Issue a NFT")] + CreateNFT(CreateNFTArgs), #[command( name = "issue-fungible", about = "Issues fungible tokens and sends them to your wallet" @@ -94,6 +114,16 @@ pub struct IssueFungibleArgs { pub supply: RustBigUint, } +#[derive(Clone, Debug, PartialEq, Eq, Args)] +pub struct IssueNFTArgs { + #[arg(short = 'c', long = "cost", default_value = "50000000000000000")] + pub cost: RustBigUint, + #[arg(short = 'd', long = "display-name")] + pub display_name: String, + #[arg(long = "token-ticker")] + pub ticker: String, +} + #[derive(Clone, Debug, PartialEq, Eq, Args)] pub struct IssueSftArgs { #[arg(short = 'c', long = "cost", default_value = "50000000000000000")] @@ -172,3 +202,64 @@ pub struct TransferNftCreateRoleArgs { #[arg(long = "new-owner")] pub new_owner: String, } + +#[derive(Clone, Debug, PartialEq, Eq, Args)] +pub struct PauseTokenArgs { + #[arg(long = "token-id", default_value = "")] + pub token_id: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, Args)] +pub struct FreezeTokenArgs { + #[arg(long = "token-id", default_value = "")] + pub token_id: String, + #[arg(short = 'a', long = "address")] + pub address: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, Args)] +pub struct FreezeNFTArgs { + #[arg(long = "token-id", default_value = "")] + pub token_id: String, + #[arg(long = "nonce")] + pub nft_nonce: u64, + #[arg(short = 'a', long = "address")] + pub address: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, Args)] +pub struct WipeTokenArgs { + #[arg(long = "token-id", default_value = "")] + pub token_id: String, + #[arg(short = 'a', long = "address")] + pub address: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, Args)] +pub struct WipeNFTArgs { + #[arg(long = "token-id", default_value = "")] + pub token_id: String, + #[arg(long = "nonce")] + pub nft_nonce: u64, + #[arg(short = 'a', long = "address")] + pub address: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, Args)] +pub struct CreateNFTArgs { + // token amount name hash royalities attributes uris + #[arg(long = "token-id")] + pub token_id: String, + #[arg(short = 'a', long = "amount")] + pub amount: RustBigUint, + #[arg(short = 'n', long = "name")] + pub name: String, + #[arg(long = "hash")] + pub hash: String, + #[arg(short = 'r', long = "royalities")] + pub royalties: u64, + // #[long = "attributes")] + // pub attributes: String, + // #[arg(long = "uris")] + // pub uris: String, +}