logos-blockchain/logos-execution-zone
1
0
Fork 0
mirror of https://github.com/logos-blockchain/logos-execution-zone.git synced 2026-07-02 11:59:52 +00:00
Code Issues Packages Projects Releases Wiki Activity
logos-execution-zone/lez/wallet/src/cli/programs/token.rs
Marvin Jones 75e4f6ac03 CI fixes
2026-07-01 10:17:38 -04:00

1655 lines
56 KiB
Rust
Raw Blame History

use anyhow::Result;
use clap::Subcommand;
use lee::AccountId;
use crate::{
AccDecodeData::Decode,
AccountIdentity, WalletCore,
account::AccountIdWithPrivacy,
cli::{CliAccountMention, SubcommandReturnValue, WalletSubcommand},
program_facades::token::Token,
};
/// Represents generic CLI subcommand for a wallet working with token program.
#[derive(Subcommand, Debug, Clone)]
pub enum TokenProgramAgnosticSubcommand {
/// Produce a new token.
New {
/// Either 32 byte base58 account id string with privacy prefix or a label.
#[arg(long)]
definition_account_id: CliAccountMention,
/// Either 32 byte base58 account id string with privacy prefix or a label.
#[arg(long)]
supply_account_id: CliAccountMention,
#[arg(short, long)]
name: String,
#[arg(short, long)]
total_supply: u128,
},
/// Send tokens from one account to another with variable privacy.
///
/// If receiver is private, then `to` and (`to_npk` , `to_vpk`) is a mutually exclusive
/// patterns.
///
/// First is used for owned accounts, second otherwise.
Send {
/// Either 32 byte base58 account id string with privacy prefix or a label.
#[arg(long)]
from: CliAccountMention,
/// Either 32 byte base58 account id string with privacy prefix or a label.
#[arg(long)]
to: Option<CliAccountMention>,
/// `to_npk` - valid 32 byte hex string.
#[arg(long, conflicts_with = "to_keys")]
to_npk: Option<String>,
/// `to_vpk` - valid hex-encoded ML-KEM-768 encapsulation key (1184 bytes).
#[arg(long, conflicts_with = "to_keys")]
to_vpk: Option<String>,
/// Path to a keys file exported by `wallet account show-keys`, containing npk
/// and vpk on separate lines. Replaces `--to-npk` and `--to-vpk`.
#[arg(long, conflicts_with_all = ["to_npk", "to_vpk"])]
to_keys: Option<String>,
/// Identifier for the recipient's private account (only used when sending to a foreign
/// private account via `--to-npk`/`--to-vpk` or `--to-keys`).
#[arg(long)]
to_identifier: Option<u128>,
/// amount - amount of balance to move.
#[arg(long)]
amount: u128,
},
/// Burn tokens on `holder`, modify `definition`.
///
/// `holder` is owned.
///
/// Also if `definition` is private then it is owned, because
/// we can not modify foreign accounts.
Burn {
/// Either 32 byte base58 account id string with privacy prefix or a label.
#[arg(long)]
definition: CliAccountMention,
/// Either 32 byte base58 account id string with privacy prefix or a label.
#[arg(long)]
holder: CliAccountMention,
/// amount - amount of balance to burn.
#[arg(long)]
amount: u128,
},
/// Mint tokens on `holder`, modify `definition`.
///
/// `definition` is owned.
///
/// If `holder` is private, then `holder` and (`holder_npk` , `holder_vpk`) is a mutually
/// exclusive patterns.
///
/// First is used for owned accounts, second otherwise.
Mint {
/// Either 32 byte base58 account id string with privacy prefix or a label.
#[arg(long)]
definition: CliAccountMention,
/// Either 32 byte base58 account id string with privacy prefix or a label.
#[arg(long)]
holder: Option<CliAccountMention>,
/// `holder_npk` - valid 32 byte hex string.
#[arg(long, conflicts_with = "holder_keys")]
holder_npk: Option<String>,
/// `holder_vpk` - valid hex-encoded ML-KEM-768 encapsulation key (1184 bytes).
#[arg(long, conflicts_with = "holder_keys")]
holder_vpk: Option<String>,
/// Path to a keys file exported by `wallet account show-keys`, containing npk
/// and vpk on separate lines. Replaces `--holder-npk` and `--holder-vpk`.
#[arg(long, conflicts_with_all = ["holder_npk", "holder_vpk"])]
holder_keys: Option<String>,
/// Identifier for the holder's private account (only used when minting to a foreign
/// private account via `--holder-npk`/`--holder-vpk` or `--holder-keys`).
#[arg(long)]
holder_identifier: Option<u128>,
/// amount - amount of balance to mint.
#[arg(long)]
amount: u128,
},
}
impl TokenProgramAgnosticSubcommand {
async fn handle_new(
definition_account_id: CliAccountMention,
supply_account_id: CliAccountMention,
name: String,
total_supply: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let def_mention = definition_account_id.clone();
let sup_mention = supply_account_id.clone();
let definition_account_id = definition_account_id.resolve(wallet_core.storage())?;
let supply_account_id = supply_account_id.resolve(wallet_core.storage())?;
let underlying_subcommand = match (definition_account_id, supply_account_id) {
(AccountIdWithPrivacy::Public(_), AccountIdWithPrivacy::Public(_)) => {
TokenProgramSubcommand::Create(
CreateNewTokenProgramSubcommand::NewPublicDefPublicSupp {
definition_account_id: def_mention,
supply_account_id: sup_mention,
name,
total_supply,
},
)
}
(
AccountIdWithPrivacy::Public(definition_account_id),
AccountIdWithPrivacy::Private(supply_account_id),
) => TokenProgramSubcommand::Create(
CreateNewTokenProgramSubcommand::NewPublicDefPrivateSupp {
definition_account_id,
supply_account_id,
name,
total_supply,
},
),
(
AccountIdWithPrivacy::Private(definition_account_id),
AccountIdWithPrivacy::Private(supply_account_id),
) => TokenProgramSubcommand::Create(
CreateNewTokenProgramSubcommand::NewPrivateDefPrivateSupp {
definition_account_id,
supply_account_id,
name,
total_supply,
},
),
(
AccountIdWithPrivacy::Private(definition_account_id),
AccountIdWithPrivacy::Public(supply_account_id),
) => TokenProgramSubcommand::Create(
CreateNewTokenProgramSubcommand::NewPrivateDefPublicSupp {
definition_account_id,
supply_account_id,
name,
total_supply,
},
),
};
underlying_subcommand.handle_subcommand(wallet_core).await
}
fn route_send_owned(
from: AccountIdWithPrivacy,
to: AccountIdWithPrivacy,
from_mention: CliAccountMention,
to_mention: Option<CliAccountMention>,
amount: u128,
) -> TokenProgramSubcommand {
match (from, to) {
(AccountIdWithPrivacy::Public(_), AccountIdWithPrivacy::Public(_)) => {
TokenProgramSubcommand::Public(TokenProgramSubcommandPublic::TransferToken {
sender_account_id: from_mention,
recipient_account_id: to_mention.expect(
"`wallet::cli::programs::token::Send`: Invalid to_mention account provided",
),
balance_to_move: amount,
})
}
(AccountIdWithPrivacy::Private(from), AccountIdWithPrivacy::Private(to)) => {
TokenProgramSubcommand::Private(
TokenProgramSubcommandPrivate::TransferTokenPrivateOwned {
sender_account_id: from,
recipient_account_id: to,
balance_to_move: amount,
},
)
}
(AccountIdWithPrivacy::Private(from), AccountIdWithPrivacy::Public(to)) => {
TokenProgramSubcommand::Deshielded(
TokenProgramSubcommandDeshielded::TransferTokenDeshielded {
sender_account_id: from,
recipient_account_id: to,
balance_to_move: amount,
},
)
}
(AccountIdWithPrivacy::Public(from), AccountIdWithPrivacy::Private(to)) => {
TokenProgramSubcommand::Shielded(
TokenProgramSubcommandShielded::TransferTokenShieldedOwned {
sender: Some(from_mention.into_public_identity(from)),
recipient_account_id: to,
balance_to_move: amount,
},
)
}
}
}
fn route_send_foreign(
from: AccountIdWithPrivacy,
from_mention: CliAccountMention,
to_npk: String,
to_vpk: String,
to_identifier: Option<u128>,
amount: u128,
) -> TokenProgramSubcommand {
match from {
AccountIdWithPrivacy::Private(from) => TokenProgramSubcommand::Private(
TokenProgramSubcommandPrivate::TransferTokenPrivateForeign {
sender_account_id: from,
recipient_npk: to_npk,
recipient_vpk: to_vpk,
recipient_identifier: to_identifier,
balance_to_move: amount,
},
),
AccountIdWithPrivacy::Public(from) => TokenProgramSubcommand::Shielded(
TokenProgramSubcommandShielded::TransferTokenShieldedForeign {
sender: Some(from_mention.into_public_identity(from)),
recipient_npk: to_npk,
recipient_vpk: to_vpk,
recipient_identifier: to_identifier,
balance_to_move: amount,
},
),
}
}
#[expect(
clippy::too_many_arguments,
reason = "extracted match arm with many destructured fields"
)]
async fn handle_send(
from: CliAccountMention,
to: Option<CliAccountMention>,
to_npk: Option<String>,
to_vpk: Option<String>,
to_keys: Option<String>,
to_identifier: Option<u128>,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let from_mention = from.clone();
let to_mention = to.clone();
let (to_npk, to_vpk) = if let Some(path) = to_keys {
let (npk_bytes, vpk_bytes) = crate::cli::read_keys_file(&path)?;
(Some(hex::encode(npk_bytes)), Some(hex::encode(vpk_bytes)))
} else {
(to_npk, to_vpk)
};
let from = from.resolve(wallet_core.storage())?;
let to = to
.map(|account_mention| account_mention.resolve(wallet_core.storage()))
.transpose()?;
let underlying_subcommand = match (to, to_npk, to_vpk) {
(None, None, None) => {
anyhow::bail!("Provide either account account_id of receiver or their public keys");
}
(Some(_), Some(_), Some(_)) => {
anyhow::bail!(
"Provide only one variant: either account account_id of receiver or their public keys"
);
}
(_, Some(_), None) | (_, None, Some(_)) => {
anyhow::bail!("List of public keys is uncomplete");
}
(Some(to), None, None) => {
Self::route_send_owned(from, to, from_mention, to_mention, amount)
}
(None, Some(to_npk), Some(to_vpk)) => {
Self::route_send_foreign(from, from_mention, to_npk, to_vpk, to_identifier, amount)
}
};
underlying_subcommand.handle_subcommand(wallet_core).await
}
async fn handle_burn(
definition: CliAccountMention,
holder: CliAccountMention,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let holder_mention = holder.clone();
let definition = definition.resolve(wallet_core.storage())?;
let holder = holder.resolve(wallet_core.storage())?;
let underlying_subcommand = match (definition, holder) {
(AccountIdWithPrivacy::Public(definition), AccountIdWithPrivacy::Public(_)) => {
TokenProgramSubcommand::Public(TokenProgramSubcommandPublic::BurnToken {
definition_account_id: definition,
holder_account_id: holder_mention,
amount,
})
}
(AccountIdWithPrivacy::Private(definition), AccountIdWithPrivacy::Private(holder)) => {
TokenProgramSubcommand::Private(
TokenProgramSubcommandPrivate::BurnTokenPrivateOwned {
definition_account_id: definition,
holder_account_id: holder,
amount,
},
)
}
(AccountIdWithPrivacy::Private(definition), AccountIdWithPrivacy::Public(holder)) => {
TokenProgramSubcommand::Deshielded(
TokenProgramSubcommandDeshielded::BurnTokenDeshieldedOwned {
definition_account_id: definition,
holder_account_id: holder,
amount,
},
)
}
(AccountIdWithPrivacy::Public(definition), AccountIdWithPrivacy::Private(holder)) => {
TokenProgramSubcommand::Shielded(
TokenProgramSubcommandShielded::BurnTokenShielded {
definition_account_id: definition,
holder_account_id: holder,
amount,
},
)
}
};
underlying_subcommand.handle_subcommand(wallet_core).await
}
fn route_mint_owned(
definition: AccountIdWithPrivacy,
holder: AccountIdWithPrivacy,
def_mention: CliAccountMention,
holder_mention: Option<CliAccountMention>,
amount: u128,
) -> TokenProgramSubcommand {
match (definition, holder) {
(AccountIdWithPrivacy::Public(_), AccountIdWithPrivacy::Public(_)) => {
TokenProgramSubcommand::Public(TokenProgramSubcommandPublic::MintToken {
definition_account_id: def_mention,
holder_account_id: holder_mention.expect("`wallet::cli::programs::token::Mint`: Invalid holder_mention account provided"),
amount,
})
}
(AccountIdWithPrivacy::Private(definition), AccountIdWithPrivacy::Private(holder)) => {
TokenProgramSubcommand::Private(
TokenProgramSubcommandPrivate::MintTokenPrivateOwned {
definition_account_id: definition,
holder_account_id: holder,
amount,
},
)
}
(AccountIdWithPrivacy::Private(definition), AccountIdWithPrivacy::Public(holder)) => {
TokenProgramSubcommand::Deshielded(
TokenProgramSubcommandDeshielded::MintTokenDeshielded {
definition_account_id: definition,
holder_account_id: holder,
amount,
},
)
}
(AccountIdWithPrivacy::Public(definition), AccountIdWithPrivacy::Private(holder)) => {
TokenProgramSubcommand::Shielded(
TokenProgramSubcommandShielded::MintTokenShieldedOwned {
definition_account_id: definition,
holder_account_id: holder,
amount,
},
)
}
}
}
const fn route_mint_foreign(
definition: AccountIdWithPrivacy,
holder_npk: String,
holder_vpk: String,
holder_identifier: Option<u128>,
amount: u128,
) -> TokenProgramSubcommand {
match definition {
AccountIdWithPrivacy::Private(definition) => TokenProgramSubcommand::Private(
TokenProgramSubcommandPrivate::MintTokenPrivateForeign {
definition_account_id: definition,
holder_npk,
holder_vpk,
holder_identifier,
amount,
},
),
AccountIdWithPrivacy::Public(definition) => TokenProgramSubcommand::Shielded(
TokenProgramSubcommandShielded::MintTokenShieldedForeign {
definition_account_id: definition,
holder_npk,
holder_vpk,
holder_identifier,
amount,
},
),
}
}
#[expect(
clippy::too_many_arguments,
reason = "extracted match arm with many destructured fields"
)]
async fn handle_mint(
definition: CliAccountMention,
holder: Option<CliAccountMention>,
holder_npk: Option<String>,
holder_vpk: Option<String>,
holder_keys: Option<String>,
holder_identifier: Option<u128>,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let def_mention = definition.clone();
let holder_mention = holder.clone();
let (holder_npk, holder_vpk) = if let Some(path) = holder_keys {
let (npk_bytes, vpk_bytes) = crate::cli::read_keys_file(&path)?;
(Some(hex::encode(npk_bytes)), Some(hex::encode(vpk_bytes)))
} else {
(holder_npk, holder_vpk)
};
let definition = definition.resolve(wallet_core.storage())?;
let holder = holder
.map(|account_mention| account_mention.resolve(wallet_core.storage()))
.transpose()?;
let underlying_subcommand = match (holder, holder_npk, holder_vpk) {
(None, None, None) => {
anyhow::bail!("Provide either account account_id of holder or their public keys");
}
(Some(_), Some(_), Some(_)) => {
anyhow::bail!(
"Provide only one variant: either account_id of holder or their public keys"
);
}
(_, Some(_), None) | (_, None, Some(_)) => {
anyhow::bail!("List of public keys is uncomplete");
}
(Some(holder), None, None) => {
Self::route_mint_owned(definition, holder, def_mention, holder_mention, amount)
}
(None, Some(holder_npk), Some(holder_vpk)) => Self::route_mint_foreign(
definition,
holder_npk,
holder_vpk,
holder_identifier,
amount,
),
};
underlying_subcommand.handle_subcommand(wallet_core).await
}
}
impl WalletSubcommand for TokenProgramAgnosticSubcommand {
async fn handle_subcommand(
self,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
match self {
Self::New {
definition_account_id,
supply_account_id,
name,
total_supply,
} => {
Self::handle_new(
definition_account_id,
supply_account_id,
name,
total_supply,
wallet_core,
)
.await
}
Self::Send {
from,
to,
to_npk,
to_vpk,
to_keys,
to_identifier,
amount,
} => {
Self::handle_send(
from,
to,
to_npk,
to_vpk,
to_keys,
to_identifier,
amount,
wallet_core,
)
.await
}
Self::Burn {
definition,
holder,
amount,
} => Self::handle_burn(definition, holder, amount, wallet_core).await,
Self::Mint {
definition,
holder,
holder_npk,
holder_vpk,
holder_keys,
holder_identifier,
amount,
} => {
Self::handle_mint(
definition,
holder,
holder_npk,
holder_vpk,
holder_keys,
holder_identifier,
amount,
wallet_core,
)
.await
}
}
}
}
/// Represents generic CLI subcommand for a wallet working with `token_program`.
#[derive(Subcommand, Debug, Clone)]
pub enum TokenProgramSubcommand {
/// Creation of new token.
#[command(subcommand)]
Create(CreateNewTokenProgramSubcommand),
/// Public execution.
#[command(subcommand)]
Public(TokenProgramSubcommandPublic),
/// Private execution.
#[command(subcommand)]
Private(TokenProgramSubcommandPrivate),
/// Deshielded execution.
#[command(subcommand)]
Deshielded(TokenProgramSubcommandDeshielded),
/// Shielded execution.
#[command(subcommand)]
Shielded(TokenProgramSubcommandShielded),
}
/// Represents generic public CLI subcommand for a wallet working with `token_program`.
#[derive(Subcommand, Debug, Clone)]
pub enum TokenProgramSubcommandPublic {
// Transfer tokens using the token program
TransferToken {
#[arg(short, long)]
sender_account_id: CliAccountMention,
#[arg(short, long)]
recipient_account_id: CliAccountMention,
#[arg(short, long)]
balance_to_move: u128,
},
// Burn tokens using the token program
BurnToken {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_account_id: CliAccountMention,
#[arg(short, long)]
amount: u128,
},
// Transfer tokens using the token program
MintToken {
#[arg(short, long)]
definition_account_id: CliAccountMention,
#[arg(short, long)]
holder_account_id: CliAccountMention,
#[arg(short, long)]
amount: u128,
},
}
/// Represents generic private CLI subcommand for a wallet working with `token_program`.
#[derive(Subcommand, Debug, Clone)]
pub enum TokenProgramSubcommandPrivate {
// Transfer tokens using the token program
TransferTokenPrivateOwned {
#[arg(short, long)]
sender_account_id: AccountId,
#[arg(short, long)]
recipient_account_id: AccountId,
#[arg(short, long)]
balance_to_move: u128,
},
// Transfer tokens using the token program
TransferTokenPrivateForeign {
#[arg(short, long)]
sender_account_id: AccountId,
/// `recipient_npk` - valid 32 byte hex string.
#[arg(long)]
recipient_npk: String,
/// `recipient_vpk` - valid hex-encoded ML-KEM-768 encapsulation key (1184 bytes).
#[arg(long)]
recipient_vpk: String,
/// Identifier for the recipient's private account.
#[arg(long)]
recipient_identifier: Option<u128>,
#[arg(short, long)]
balance_to_move: u128,
},
// Burn tokens using the token program
BurnTokenPrivateOwned {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_account_id: AccountId,
#[arg(short, long)]
amount: u128,
},
// Transfer tokens using the token program
MintTokenPrivateOwned {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_account_id: AccountId,
#[arg(short, long)]
amount: u128,
},
// Transfer tokens using the token program
MintTokenPrivateForeign {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_npk: String,
#[arg(short, long)]
holder_vpk: String,
/// Identifier for the holder's private account.
#[arg(long)]
holder_identifier: Option<u128>,
#[arg(short, long)]
amount: u128,
},
}
/// Represents deshielded public CLI subcommand for a wallet working with `token_program`.
#[derive(Subcommand, Debug, Clone)]
pub enum TokenProgramSubcommandDeshielded {
// Transfer tokens using the token program
TransferTokenDeshielded {
#[arg(short, long)]
sender_account_id: AccountId,
#[arg(short, long)]
recipient_account_id: AccountId,
#[arg(short, long)]
balance_to_move: u128,
},
// Burn tokens using the token program
BurnTokenDeshieldedOwned {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_account_id: AccountId,
#[arg(short, long)]
amount: u128,
},
// Transfer tokens using the token program
MintTokenDeshielded {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_account_id: AccountId,
#[arg(short, long)]
amount: u128,
},
}
/// Represents generic shielded CLI subcommand for a wallet working with `token_program`.
#[derive(Subcommand, Debug, Clone)]
pub enum TokenProgramSubcommandShielded {
// Transfer tokens using the token program
TransferTokenShieldedOwned {
#[arg(skip)]
sender: Option<AccountIdentity>,
#[arg(short, long)]
recipient_account_id: AccountId,
#[arg(short, long)]
balance_to_move: u128,
},
// Transfer tokens using the token program
TransferTokenShieldedForeign {
#[arg(skip)]
sender: Option<AccountIdentity>,
/// `recipient_npk` - valid 32 byte hex string.
#[arg(long)]
recipient_npk: String,
/// `recipient_vpk` - valid hex-encoded ML-KEM-768 encapsulation key (1184 bytes).
#[arg(long)]
recipient_vpk: String,
/// Identifier for the recipient's private account.
#[arg(long)]
recipient_identifier: Option<u128>,
#[arg(short, long)]
balance_to_move: u128,
},
// Burn tokens using the token program
BurnTokenShielded {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_account_id: AccountId,
#[arg(short, long)]
amount: u128,
},
// Transfer tokens using the token program
MintTokenShieldedOwned {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_account_id: AccountId,
#[arg(short, long)]
amount: u128,
},
// Transfer tokens using the token program
MintTokenShieldedForeign {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
holder_npk: String,
#[arg(short, long)]
holder_vpk: String,
/// Identifier for the holder's private account.
#[arg(long)]
holder_identifier: Option<u128>,
#[arg(short, long)]
amount: u128,
},
}
/// Represents generic initialization subcommand for a wallet working with `token_program`.
#[derive(Subcommand, Debug, Clone)]
pub enum CreateNewTokenProgramSubcommand {
/// Create a new token using the token program.
///
/// Definition - public, supply - public.
NewPublicDefPublicSupp {
#[arg(short, long)]
definition_account_id: CliAccountMention,
#[arg(short, long)]
supply_account_id: CliAccountMention,
#[arg(short, long)]
name: String,
#[arg(short, long)]
total_supply: u128,
},
/// Create a new token using the token program.
///
/// Definition - public, supply - private.
NewPublicDefPrivateSupp {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
supply_account_id: AccountId,
#[arg(short, long)]
name: String,
#[arg(short, long)]
total_supply: u128,
},
/// Create a new token using the token program.
///
/// Definition - private, supply - public.
NewPrivateDefPublicSupp {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
supply_account_id: AccountId,
#[arg(short, long)]
name: String,
#[arg(short, long)]
total_supply: u128,
},
/// Create a new token using the token program.
///
/// Definition - private, supply - private.
NewPrivateDefPrivateSupp {
#[arg(short, long)]
definition_account_id: AccountId,
#[arg(short, long)]
supply_account_id: AccountId,
#[arg(short, long)]
name: String,
#[arg(short, long)]
total_supply: u128,
},
}
impl TokenProgramSubcommandPublic {
async fn handle_transfer_token(
sender_account_id: CliAccountMention,
recipient_account_id: CliAccountMention,
balance_to_move: u128,
wallet_core: &WalletCore,
) -> Result<SubcommandReturnValue> {
let sender = sender_account_id.resolve(wallet_core.storage())?;
let recipient = recipient_account_id.resolve(wallet_core.storage())?;
let (AccountIdWithPrivacy::Public(sender_id), AccountIdWithPrivacy::Public(recipient_id)) =
(sender, recipient)
else {
anyhow::bail!(
"`TokenProgramSubcommandPublic::TransferToken`: Unexpected private account received."
);
};
let tx_hash = Token(wallet_core)
.send_transfer_transaction(
sender_account_id.into_public_identity(sender_id),
recipient_account_id.into_public_identity(recipient_id),
balance_to_move,
)
.await?;
wallet_core
.poll_and_finalize_public_transaction(tx_hash)
.await
}
async fn handle_burn_token(
definition_account_id: AccountId,
holder_account_id: CliAccountMention,
amount: u128,
wallet_core: &WalletCore,
) -> Result<SubcommandReturnValue> {
let holder = holder_account_id.resolve(wallet_core.storage())?;
let AccountIdWithPrivacy::Public(holder_id) = holder else {
anyhow::bail!(
"`TokenProgramSubcommandPublic::BurnToken`: holder account must be public."
);
};
let tx_hash = Token(wallet_core)
.send_burn_transaction(
definition_account_id,
holder_account_id.into_public_identity(holder_id),
amount,
)
.await?;
wallet_core
.poll_and_finalize_public_transaction(tx_hash)
.await
}
async fn handle_mint_token(
definition_account_id: CliAccountMention,
holder_account_id: CliAccountMention,
amount: u128,
wallet_core: &WalletCore,
) -> Result<SubcommandReturnValue> {
let definition = definition_account_id.resolve(wallet_core.storage())?;
let holder = holder_account_id.resolve(wallet_core.storage())?;
let (AccountIdWithPrivacy::Public(def_id), AccountIdWithPrivacy::Public(holder_id)) =
(definition, holder)
else {
anyhow::bail!(
"`TokenProgramSubcommandPublic::MintToken`: holder account must be public."
);
};
let tx_hash = Token(wallet_core)
.send_mint_transaction(
definition_account_id.into_public_identity(def_id),
holder_account_id.into_public_identity(holder_id),
amount,
)
.await?;
wallet_core
.poll_and_finalize_public_transaction(tx_hash)
.await
}
}
impl WalletSubcommand for TokenProgramSubcommandPublic {
async fn handle_subcommand(
self,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
match self {
Self::TransferToken {
sender_account_id,
recipient_account_id,
balance_to_move,
} => {
Self::handle_transfer_token(
sender_account_id,
recipient_account_id,
balance_to_move,
wallet_core,
)
.await
}
Self::BurnToken {
definition_account_id,
holder_account_id,
amount,
} => {
Self::handle_burn_token(
definition_account_id,
holder_account_id,
amount,
wallet_core,
)
.await
}
Self::MintToken {
definition_account_id,
holder_account_id,
amount,
} => {
Self::handle_mint_token(
definition_account_id,
holder_account_id,
amount,
wallet_core,
)
.await
}
}
}
}
impl TokenProgramSubcommandPrivate {
async fn handle_transfer_token_private_owned(
sender_account_id: AccountId,
recipient_account_id: AccountId,
balance_to_move: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, [secret_sender, secret_recipient]) = Token(wallet_core)
.send_transfer_transaction_private_owned_account(
sender_account_id,
recipient_account_id,
balance_to_move,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[
Decode(secret_sender, sender_account_id),
Decode(secret_recipient, recipient_account_id),
],
)
.await
}
async fn handle_transfer_token_private_foreign(
sender_account_id: AccountId,
recipient_npk: String,
recipient_vpk: String,
recipient_identifier: Option<u128>,
balance_to_move: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (recipient_npk, recipient_vpk) =
crate::cli::decode_npk_vpk(&recipient_npk, &recipient_vpk)?;
let (tx_hash, [secret_sender, _]) = Token(wallet_core)
.send_transfer_transaction_private_foreign_account(
sender_account_id,
recipient_npk,
recipient_vpk,
recipient_identifier.unwrap_or_else(rand::random),
balance_to_move,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(tx_hash, &[Decode(secret_sender, sender_account_id)])
.await
}
async fn handle_burn_token_private_owned(
definition_account_id: AccountId,
holder_account_id: AccountId,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, [secret_definition, secret_holder]) = Token(wallet_core)
.send_burn_transaction_private_owned_account(
definition_account_id,
holder_account_id,
amount,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[
Decode(secret_definition, definition_account_id),
Decode(secret_holder, holder_account_id),
],
)
.await
}
async fn handle_mint_token_private_owned(
definition_account_id: AccountId,
holder_account_id: AccountId,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, [secret_definition, secret_holder]) = Token(wallet_core)
.send_mint_transaction_private_owned_account(
definition_account_id,
holder_account_id,
amount,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[
Decode(secret_definition, definition_account_id),
Decode(secret_holder, holder_account_id),
],
)
.await
}
async fn handle_mint_token_private_foreign(
definition_account_id: AccountId,
holder_npk: String,
holder_vpk: String,
holder_identifier: Option<u128>,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (holder_npk, holder_vpk) = crate::cli::decode_npk_vpk(&holder_npk, &holder_vpk)?;
let (tx_hash, [secret_definition, _]) = Token(wallet_core)
.send_mint_transaction_private_foreign_account(
definition_account_id,
holder_npk,
holder_vpk,
holder_identifier.unwrap_or_else(rand::random),
amount,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[Decode(secret_definition, definition_account_id)],
)
.await
}
}
impl WalletSubcommand for TokenProgramSubcommandPrivate {
async fn handle_subcommand(
self,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
match self {
Self::TransferTokenPrivateOwned {
sender_account_id,
recipient_account_id,
balance_to_move,
} => {
Self::handle_transfer_token_private_owned(
sender_account_id,
recipient_account_id,
balance_to_move,
wallet_core,
)
.await
}
Self::TransferTokenPrivateForeign {
sender_account_id,
recipient_npk,
recipient_vpk,
recipient_identifier,
balance_to_move,
} => {
Self::handle_transfer_token_private_foreign(
sender_account_id,
recipient_npk,
recipient_vpk,
recipient_identifier,
balance_to_move,
wallet_core,
)
.await
}
Self::BurnTokenPrivateOwned {
definition_account_id,
holder_account_id,
amount,
} => {
Self::handle_burn_token_private_owned(
definition_account_id,
holder_account_id,
amount,
wallet_core,
)
.await
}
Self::MintTokenPrivateOwned {
definition_account_id,
holder_account_id,
amount,
} => {
Self::handle_mint_token_private_owned(
definition_account_id,
holder_account_id,
amount,
wallet_core,
)
.await
}
Self::MintTokenPrivateForeign {
definition_account_id,
holder_npk,
holder_vpk,
holder_identifier,
amount,
} => {
Self::handle_mint_token_private_foreign(
definition_account_id,
holder_npk,
holder_vpk,
holder_identifier,
amount,
wallet_core,
)
.await
}
}
}
}
impl TokenProgramSubcommandDeshielded {
async fn handle_transfer_token_deshielded(
sender_account_id: AccountId,
recipient_account_id: AccountId,
balance_to_move: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, secret_sender) = Token(wallet_core)
.send_transfer_transaction_deshielded(
sender_account_id,
recipient_account_id,
balance_to_move,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(tx_hash, &[Decode(secret_sender, sender_account_id)])
.await
}
async fn handle_burn_token_deshielded_owned(
definition_account_id: AccountId,
holder_account_id: AccountId,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, secret_definition) = Token(wallet_core)
.send_burn_transaction_deshielded_owned_account(
definition_account_id,
holder_account_id,
amount,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[Decode(secret_definition, definition_account_id)],
)
.await
}
async fn handle_mint_token_deshielded(
definition_account_id: AccountId,
holder_account_id: AccountId,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, secret_definition) = Token(wallet_core)
.send_mint_transaction_deshielded(definition_account_id, holder_account_id, amount)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[Decode(secret_definition, definition_account_id)],
)
.await
}
}
impl WalletSubcommand for TokenProgramSubcommandDeshielded {
async fn handle_subcommand(
self,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
match self {
Self::TransferTokenDeshielded {
sender_account_id,
recipient_account_id,
balance_to_move,
} => {
Self::handle_transfer_token_deshielded(
sender_account_id,
recipient_account_id,
balance_to_move,
wallet_core,
)
.await
}
Self::BurnTokenDeshieldedOwned {
definition_account_id,
holder_account_id,
amount,
} => {
Self::handle_burn_token_deshielded_owned(
definition_account_id,
holder_account_id,
amount,
wallet_core,
)
.await
}
Self::MintTokenDeshielded {
definition_account_id,
holder_account_id,
amount,
} => {
Self::handle_mint_token_deshielded(
definition_account_id,
holder_account_id,
amount,
wallet_core,
)
.await
}
}
}
}
impl TokenProgramSubcommandShielded {
async fn handle_transfer_token_shielded_foreign(
sender: Option<AccountIdentity>,
recipient_npk: String,
recipient_vpk: String,
recipient_identifier: Option<u128>,
balance_to_move: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (recipient_npk, recipient_vpk) =
crate::cli::decode_npk_vpk(&recipient_npk, &recipient_vpk)?;
let (tx_hash, _) = Token(wallet_core)
.send_transfer_transaction_shielded_foreign_account(
sender.expect("sender set during Send dispatch"),
recipient_npk,
recipient_vpk,
recipient_identifier.unwrap_or_else(rand::random),
balance_to_move,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(tx_hash, &[])
.await
}
async fn handle_transfer_token_shielded_owned(
sender: Option<AccountIdentity>,
recipient_account_id: AccountId,
balance_to_move: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, secret_recipient) = Token(wallet_core)
.send_transfer_transaction_shielded_owned_account(
sender.expect("sender set during Send dispatch"),
recipient_account_id,
balance_to_move,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[Decode(secret_recipient, recipient_account_id)],
)
.await
}
async fn handle_burn_token_shielded(
definition_account_id: AccountId,
holder_account_id: AccountId,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, secret_holder) = Token(wallet_core)
.send_burn_transaction_shielded(definition_account_id, holder_account_id, amount)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(tx_hash, &[Decode(secret_holder, holder_account_id)])
.await
}
async fn handle_mint_token_shielded_owned(
definition_account_id: AccountId,
holder_account_id: AccountId,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, secret_holder) = Token(wallet_core)
.send_mint_transaction_shielded_owned_account(
definition_account_id,
holder_account_id,
amount,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(tx_hash, &[Decode(secret_holder, holder_account_id)])
.await
}
async fn handle_mint_token_shielded_foreign(
definition_account_id: AccountId,
holder_npk: String,
holder_vpk: String,
holder_identifier: Option<u128>,
amount: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (holder_npk, holder_vpk) = crate::cli::decode_npk_vpk(&holder_npk, &holder_vpk)?;
let (tx_hash, _) = Token(wallet_core)
.send_mint_transaction_shielded_foreign_account(
definition_account_id,
holder_npk,
holder_vpk,
holder_identifier.unwrap_or_else(rand::random),
amount,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(tx_hash, &[])
.await
}
}
impl WalletSubcommand for TokenProgramSubcommandShielded {
async fn handle_subcommand(
self,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
match self {
Self::TransferTokenShieldedForeign {
sender,
recipient_npk,
recipient_vpk,
recipient_identifier,
balance_to_move,
} => {
Self::handle_transfer_token_shielded_foreign(
sender,
recipient_npk,
recipient_vpk,
recipient_identifier,
balance_to_move,
wallet_core,
)
.await
}
Self::TransferTokenShieldedOwned {
sender,
recipient_account_id,
balance_to_move,
} => {
Self::handle_transfer_token_shielded_owned(
sender,
recipient_account_id,
balance_to_move,
wallet_core,
)
.await
}
Self::BurnTokenShielded {
definition_account_id,
holder_account_id,
amount,
} => {
Self::handle_burn_token_shielded(
definition_account_id,
holder_account_id,
amount,
wallet_core,
)
.await
}
Self::MintTokenShieldedOwned {
definition_account_id,
holder_account_id,
amount,
} => {
Self::handle_mint_token_shielded_owned(
definition_account_id,
holder_account_id,
amount,
wallet_core,
)
.await
}
Self::MintTokenShieldedForeign {
definition_account_id,
holder_npk,
holder_vpk,
holder_identifier,
amount,
} => {
Self::handle_mint_token_shielded_foreign(
definition_account_id,
holder_npk,
holder_vpk,
holder_identifier,
amount,
wallet_core,
)
.await
}
}
}
}
impl CreateNewTokenProgramSubcommand {
async fn handle_new_private_def_private_supp(
definition_account_id: AccountId,
supply_account_id: AccountId,
name: String,
total_supply: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, [secret_definition, secret_supply]) = Token(wallet_core)
.send_new_definition_private_owned_definiton_and_supply(
definition_account_id,
supply_account_id,
name,
total_supply,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[
Decode(secret_definition, definition_account_id),
Decode(secret_supply, supply_account_id),
],
)
.await
}
async fn handle_new_private_def_public_supp(
definition_account_id: AccountId,
supply_account_id: AccountId,
name: String,
total_supply: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, secret_definition) = Token(wallet_core)
.send_new_definition_private_owned_definiton(
definition_account_id,
supply_account_id,
name,
total_supply,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(
tx_hash,
&[Decode(secret_definition, definition_account_id)],
)
.await
}
async fn handle_new_public_def_private_supp(
definition_account_id: AccountId,
supply_account_id: AccountId,
name: String,
total_supply: u128,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
let (tx_hash, secret_supply) = Token(wallet_core)
.send_new_definition_private_owned_supply(
definition_account_id,
supply_account_id,
name,
total_supply,
)
.await?;
wallet_core
.poll_and_finalize_pp_transaction(tx_hash, &[Decode(secret_supply, supply_account_id)])
.await
}
async fn handle_new_public_def_public_supp(
definition_account_id: CliAccountMention,
supply_account_id: CliAccountMention,
name: String,
total_supply: u128,
wallet_core: &WalletCore,
) -> Result<SubcommandReturnValue> {
let definition = definition_account_id.resolve(wallet_core.storage())?;
let supply = supply_account_id.resolve(wallet_core.storage())?;
let (AccountIdWithPrivacy::Public(def_id), AccountIdWithPrivacy::Public(sup_id)) =
(definition, supply)
else {
anyhow::bail!("`NewPublicDefPublicSupp`: unexpected private account received.");
};
let tx_hash = Token(wallet_core)
.send_new_definition(
definition_account_id.into_public_identity(def_id),
supply_account_id.into_public_identity(sup_id),
name,
total_supply,
)
.await?;
wallet_core
.poll_and_finalize_public_transaction(tx_hash)
.await
}
}
impl WalletSubcommand for CreateNewTokenProgramSubcommand {
async fn handle_subcommand(
self,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
match self {
Self::NewPrivateDefPrivateSupp {
definition_account_id,
supply_account_id,
name,
total_supply,
} => {
Self::handle_new_private_def_private_supp(
definition_account_id,
supply_account_id,
name,
total_supply,
wallet_core,
)
.await
}
Self::NewPrivateDefPublicSupp {
definition_account_id,
supply_account_id,
name,
total_supply,
} => {
Self::handle_new_private_def_public_supp(
definition_account_id,
supply_account_id,
name,
total_supply,
wallet_core,
)
.await
}
Self::NewPublicDefPrivateSupp {
definition_account_id,
supply_account_id,
name,
total_supply,
} => {
Self::handle_new_public_def_private_supp(
definition_account_id,
supply_account_id,
name,
total_supply,
wallet_core,
)
.await
}
Self::NewPublicDefPublicSupp {
definition_account_id,
supply_account_id,
name,
total_supply,
} => {
Self::handle_new_public_def_public_supp(
definition_account_id,
supply_account_id,
name,
total_supply,
wallet_core,
)
.await
}
}
}
}
impl WalletSubcommand for TokenProgramSubcommand {
async fn handle_subcommand(
self,
wallet_core: &mut WalletCore,
) -> Result<SubcommandReturnValue> {
match self {
Self::Create(creation_subcommand) => {
creation_subcommand.handle_subcommand(wallet_core).await
}
Self::Private(private_subcommand) => {
private_subcommand.handle_subcommand(wallet_core).await
}
Self::Public(public_subcommand) => {
public_subcommand.handle_subcommand(wallet_core).await
}
Self::Deshielded(deshielded_subcommand) => {
deshielded_subcommand.handle_subcommand(wallet_core).await
}
Self::Shielded(shielded_subcommand) => {
shielded_subcommand.handle_subcommand(wallet_core).await
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink