mirror of
https://github.com/logos-blockchain/lssa.git
synced 2026-01-02 13:23:10 +00:00
668 lines
24 KiB
Rust
668 lines
24 KiB
Rust
use common::{error::ExecutionFailureKind, rpc_primitives::requests::SendTxResponse};
|
|
use nssa::{AccountId, program::Program};
|
|
use nssa_core::{NullifierPublicKey, SharedSecretKey, encryption::IncomingViewingPublicKey};
|
|
|
|
use crate::{PrivacyPreservingAccount, WalletCore};
|
|
|
|
pub struct Token<'w>(pub &'w WalletCore);
|
|
|
|
impl Token<'_> {
|
|
pub async fn send_new_definition(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
supply_account_id: AccountId,
|
|
name: [u8; 6],
|
|
total_supply: u128,
|
|
) -> Result<SendTxResponse, ExecutionFailureKind> {
|
|
let account_ids = vec![definition_account_id, supply_account_id];
|
|
let program_id = nssa::program::Program::token().id();
|
|
// Instruction must be: [0x00 || total_supply (little-endian 16 bytes) || name (6 bytes)]
|
|
let mut instruction = vec![0u8; 23];
|
|
instruction[1..17].copy_from_slice(&total_supply.to_le_bytes());
|
|
instruction[17..].copy_from_slice(&name);
|
|
let message = nssa::public_transaction::Message::try_new(
|
|
program_id,
|
|
account_ids,
|
|
vec![],
|
|
instruction,
|
|
)
|
|
.unwrap();
|
|
|
|
let witness_set = nssa::public_transaction::WitnessSet::for_message(&message, &[]);
|
|
|
|
let tx = nssa::PublicTransaction::new(message, witness_set);
|
|
|
|
Ok(self.0.sequencer_client.send_tx_public(tx).await?)
|
|
}
|
|
|
|
pub async fn send_new_definition_private_owned_supply(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
supply_account_id: AccountId,
|
|
name: [u8; 6],
|
|
total_supply: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_definition(name, total_supply);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::Public(definition_account_id),
|
|
PrivacyPreservingAccount::PrivateOwned(supply_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected supply's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_new_definition_private_owned_definiton(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
supply_account_id: AccountId,
|
|
name: [u8; 6],
|
|
total_supply: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_definition(name, total_supply);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(definition_account_id),
|
|
PrivacyPreservingAccount::Public(supply_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected definition's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_new_definition_private_owned_definiton_and_supply(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
supply_account_id: AccountId,
|
|
name: [u8; 6],
|
|
total_supply: u128,
|
|
) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_definition(name, total_supply);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(definition_account_id),
|
|
PrivacyPreservingAccount::PrivateOwned(supply_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let mut iter = secrets.into_iter();
|
|
let first = iter.next().expect("expected definition's secret");
|
|
let second = iter.next().expect("expected supply's secret");
|
|
(resp, [first, second])
|
|
})
|
|
}
|
|
|
|
pub async fn send_transfer_transaction(
|
|
&self,
|
|
sender_account_id: AccountId,
|
|
recipient_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<SendTxResponse, ExecutionFailureKind> {
|
|
let account_ids = vec![sender_account_id, recipient_account_id];
|
|
let program_id = nssa::program::Program::token().id();
|
|
// Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 ||
|
|
// 0x00 || 0x00 || 0x00].
|
|
let mut instruction = vec![0u8; 23];
|
|
instruction[0] = 0x01;
|
|
instruction[1..17].copy_from_slice(&amount.to_le_bytes());
|
|
let Ok(nonces) = self.0.get_accounts_nonces(vec![sender_account_id]).await else {
|
|
return Err(ExecutionFailureKind::SequencerError);
|
|
};
|
|
let message = nssa::public_transaction::Message::try_new(
|
|
program_id,
|
|
account_ids,
|
|
nonces,
|
|
instruction,
|
|
)
|
|
.unwrap();
|
|
|
|
let Some(signing_key) = self
|
|
.0
|
|
.storage
|
|
.user_data
|
|
.get_pub_account_signing_key(&sender_account_id)
|
|
else {
|
|
return Err(ExecutionFailureKind::KeyNotFoundError);
|
|
};
|
|
let witness_set =
|
|
nssa::public_transaction::WitnessSet::for_message(&message, &[signing_key]);
|
|
|
|
let tx = nssa::PublicTransaction::new(message, witness_set);
|
|
|
|
Ok(self.0.sequencer_client.send_tx_public(tx).await?)
|
|
}
|
|
|
|
pub async fn send_transfer_transaction_private_owned_account(
|
|
&self,
|
|
sender_account_id: AccountId,
|
|
recipient_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_transfer(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(sender_account_id),
|
|
PrivacyPreservingAccount::PrivateOwned(recipient_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let mut iter = secrets.into_iter();
|
|
let first = iter.next().expect("expected sender's secret");
|
|
let second = iter.next().expect("expected recipient's secret");
|
|
(resp, [first, second])
|
|
})
|
|
}
|
|
|
|
pub async fn send_transfer_transaction_private_foreign_account(
|
|
&self,
|
|
sender_account_id: AccountId,
|
|
recipient_npk: NullifierPublicKey,
|
|
recipient_ipk: IncomingViewingPublicKey,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_transfer(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(sender_account_id),
|
|
PrivacyPreservingAccount::PrivateForeign {
|
|
npk: recipient_npk,
|
|
ipk: recipient_ipk,
|
|
},
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let mut iter = secrets.into_iter();
|
|
let first = iter.next().expect("expected sender's secret");
|
|
let second = iter.next().expect("expected recipient's secret");
|
|
(resp, [first, second])
|
|
})
|
|
}
|
|
|
|
pub async fn send_transfer_transaction_deshielded(
|
|
&self,
|
|
sender_account_id: AccountId,
|
|
recipient_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_transfer(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(sender_account_id),
|
|
PrivacyPreservingAccount::Public(recipient_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected sender's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_transfer_transaction_shielded_owned_account(
|
|
&self,
|
|
sender_account_id: AccountId,
|
|
recipient_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_transfer(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::Public(sender_account_id),
|
|
PrivacyPreservingAccount::PrivateOwned(recipient_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected recipient's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_transfer_transaction_shielded_foreign_account(
|
|
&self,
|
|
sender_account_id: AccountId,
|
|
recipient_npk: NullifierPublicKey,
|
|
recipient_ipk: IncomingViewingPublicKey,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_transfer(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::Public(sender_account_id),
|
|
PrivacyPreservingAccount::PrivateForeign {
|
|
npk: recipient_npk,
|
|
ipk: recipient_ipk,
|
|
},
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected recipient's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_burn_transaction(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<SendTxResponse, ExecutionFailureKind> {
|
|
let account_ids = vec![definition_account_id, holder_account_id];
|
|
let instruction = token_program_preparation_burn(amount);
|
|
|
|
let Ok(nonces) = self.0.get_accounts_nonces(vec![holder_account_id]).await else {
|
|
return Err(ExecutionFailureKind::SequencerError);
|
|
};
|
|
let message = nssa::public_transaction::Message::try_new(
|
|
Program::token().id(),
|
|
account_ids,
|
|
nonces,
|
|
instruction,
|
|
)
|
|
.expect("Instruction should serialize");
|
|
|
|
let signing_key = self
|
|
.0
|
|
.storage
|
|
.user_data
|
|
.get_pub_account_signing_key(&holder_account_id)
|
|
.ok_or(ExecutionFailureKind::KeyNotFoundError)?;
|
|
let witness_set =
|
|
nssa::public_transaction::WitnessSet::for_message(&message, &[signing_key]);
|
|
|
|
let tx = nssa::PublicTransaction::new(message, witness_set);
|
|
|
|
Ok(self.0.sequencer_client.send_tx_public(tx).await?)
|
|
}
|
|
|
|
pub async fn send_burn_transaction_private_owned_account(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_burn(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(definition_account_id),
|
|
PrivacyPreservingAccount::PrivateOwned(holder_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let mut iter = secrets.into_iter();
|
|
let first = iter.next().expect("expected definition's secret");
|
|
let second = iter.next().expect("expected holder's secret");
|
|
(resp, [first, second])
|
|
})
|
|
}
|
|
|
|
pub async fn send_burn_transaction_deshielded_owned_account(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_burn(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(definition_account_id),
|
|
PrivacyPreservingAccount::Public(holder_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected definition's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_burn_transaction_shielded(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_burn(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::Public(definition_account_id),
|
|
PrivacyPreservingAccount::PrivateOwned(holder_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected holder's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_mint_transaction(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<SendTxResponse, ExecutionFailureKind> {
|
|
let account_ids = vec![definition_account_id, holder_account_id];
|
|
let instruction = token_program_preparation_mint(amount);
|
|
|
|
let Ok(nonces) = self
|
|
.0
|
|
.get_accounts_nonces(vec![definition_account_id])
|
|
.await
|
|
else {
|
|
return Err(ExecutionFailureKind::SequencerError);
|
|
};
|
|
let message = nssa::public_transaction::Message::try_new(
|
|
Program::token().id(),
|
|
account_ids,
|
|
nonces,
|
|
instruction,
|
|
)
|
|
.unwrap();
|
|
|
|
let Some(signing_key) = self
|
|
.0
|
|
.storage
|
|
.user_data
|
|
.get_pub_account_signing_key(&definition_account_id)
|
|
else {
|
|
return Err(ExecutionFailureKind::KeyNotFoundError);
|
|
};
|
|
let witness_set =
|
|
nssa::public_transaction::WitnessSet::for_message(&message, &[signing_key]);
|
|
|
|
let tx = nssa::PublicTransaction::new(message, witness_set);
|
|
|
|
Ok(self.0.sequencer_client.send_tx_public(tx).await?)
|
|
}
|
|
|
|
pub async fn send_mint_transaction_private_owned_account(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_mint(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(definition_account_id),
|
|
PrivacyPreservingAccount::PrivateOwned(holder_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let mut iter = secrets.into_iter();
|
|
let first = iter.next().expect("expected definition's secret");
|
|
let second = iter.next().expect("expected holder's secret");
|
|
(resp, [first, second])
|
|
})
|
|
}
|
|
|
|
pub async fn send_mint_transaction_private_foreign_account(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_npk: NullifierPublicKey,
|
|
holder_ipk: IncomingViewingPublicKey,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_mint(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(definition_account_id),
|
|
PrivacyPreservingAccount::PrivateForeign {
|
|
npk: holder_npk,
|
|
ipk: holder_ipk,
|
|
},
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let mut iter = secrets.into_iter();
|
|
let first = iter.next().expect("expected definition's secret");
|
|
let second = iter.next().expect("expected holder's secret");
|
|
(resp, [first, second])
|
|
})
|
|
}
|
|
|
|
pub async fn send_mint_transaction_deshielded(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_mint(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::PrivateOwned(definition_account_id),
|
|
PrivacyPreservingAccount::Public(holder_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected definition's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_mint_transaction_shielded_owned_account(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_account_id: AccountId,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_mint(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::Public(definition_account_id),
|
|
PrivacyPreservingAccount::PrivateOwned(holder_account_id),
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected holder's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
|
|
pub async fn send_mint_transaction_shielded_foreign_account(
|
|
&self,
|
|
definition_account_id: AccountId,
|
|
holder_npk: NullifierPublicKey,
|
|
holder_ipk: IncomingViewingPublicKey,
|
|
amount: u128,
|
|
) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> {
|
|
let instruction = token_program_preparation_mint(amount);
|
|
let instruction_data =
|
|
Program::serialize_instruction(instruction).expect("Instruction should serialize");
|
|
|
|
self.0
|
|
.send_privacy_preserving_tx(
|
|
vec![
|
|
PrivacyPreservingAccount::Public(definition_account_id),
|
|
PrivacyPreservingAccount::PrivateForeign {
|
|
npk: holder_npk,
|
|
ipk: holder_ipk,
|
|
},
|
|
],
|
|
&instruction_data,
|
|
&Program::token().into(),
|
|
)
|
|
.await
|
|
.map(|(resp, secrets)| {
|
|
let first = secrets
|
|
.into_iter()
|
|
.next()
|
|
.expect("expected holder's secret");
|
|
(resp, first)
|
|
})
|
|
}
|
|
}
|
|
|
|
fn token_program_preparation_transfer(amount: u128) -> Vec<u8> {
|
|
// Instruction must be: [0x01 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 ||
|
|
// 0x00 || 0x00 || 0x00].
|
|
let mut instruction = vec![0u8; 23];
|
|
instruction[0] = 0x01;
|
|
instruction[1..17].copy_from_slice(&amount.to_le_bytes());
|
|
|
|
instruction
|
|
}
|
|
|
|
fn token_program_preparation_definition(name: [u8; 6], total_supply: u128) -> Vec<u8> {
|
|
// Instruction must be: [0x00 || total_supply (little-endian 16 bytes) || name (6 bytes)]
|
|
let mut instruction = vec![0u8; 23];
|
|
instruction[1..17].copy_from_slice(&total_supply.to_le_bytes());
|
|
instruction[17..].copy_from_slice(&name);
|
|
|
|
instruction
|
|
}
|
|
|
|
fn token_program_preparation_burn(amount: u128) -> Vec<u8> {
|
|
// Instruction must be: [0x03 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 ||
|
|
// 0x00 || 0x00 || 0x00].
|
|
let mut instruction = vec![0; 23];
|
|
instruction[0] = 0x03;
|
|
instruction[1..17].copy_from_slice(&amount.to_le_bytes());
|
|
|
|
instruction
|
|
}
|
|
|
|
fn token_program_preparation_mint(amount: u128) -> Vec<u8> {
|
|
// Instruction must be: [0x04 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 ||
|
|
// 0x00 || 0x00 || 0x00].
|
|
let mut instruction = vec![0; 23];
|
|
instruction[0] = 0x04;
|
|
instruction[1..17].copy_from_slice(&amount.to_le_bytes());
|
|
|
|
instruction
|
|
}
|