diff --git a/assets/dusk_wallet_core.wasm b/assets/dusk_wallet_core.wasm deleted file mode 100755 index 47533d3..0000000 Binary files a/assets/dusk_wallet_core.wasm and /dev/null differ diff --git a/assets/schema.json b/assets/schema.json index 73ae3fe..5ae57f3 100644 --- a/assets/schema.json +++ b/assets/schema.json @@ -798,7 +798,7 @@ } } }, - "getStctProof": { + "GetStctProofArgs": { "description": "Get the bytes for the stct proof to send to the node", "type": "object", "required": ["rng_seed", "seed", "refund", "value", "sender_index", "gas_limit", "gas_price"], @@ -840,6 +840,93 @@ "type": "integer" } } + }, + "GetStctProofResponse": { + "description": "Response of the get_stct_proof function", + "type": "object", + "required": ["bytes", "signature"], + "properties": { + "bytes": { + "description": "The bytes of the stct proof to send to the node", + "type": "array", + "items": { + "type": "integer", + "format": "uint8" + } + }, + "signature": { + "description": "The signature of the stct proof", + "type": "array", + "items": { + "type": "integer", + "format": "uint8" + } + } + } + }, + "GetStakeCallDataArgs": { + "description": "Get the call data for stakeing", + "type": "object", + "required": ["staker_index", "seed", "spend_proof", "value", "signature"], + "properties": { + "staker_index": { + "description": "Index of the address of the staker in the seed", + "type": "integer", + "format": "uint8" + }, + "seed": { + "description": "The seed to generate the sender keys from", + "type": "array", + "items": { + "type": "integer", + "format": "uint8" + } + }, + "spend_proof": { + "description": "The stct proof as recieved from the node", + "type": "array", + "items": { + "type": "integer", + "format": "uint8" + } + }, + "value": { + "description": "The amount of value to stake", + "type": "integer", + "format": "uint64" + }, + "signature": { + "description": "The signature of the stct proof", + "type": "array", + "items": { + "type": "integer", + "format": "uint8" + } + } + } + }, + "GetStakeCallDataResponse": { + "description": "Response of the get_stake_call_data function, send this to the call_data in execute", + "type": "object", + "required": ["contract", "method", "payload"], + "properties": { + "contract": { + "description": "The contract to call encoded in bs58 format", + "type": "string" + }, + "method": { + "description": "The method to call on the contract", + "type": "string" + }, + "payload": { + "description": "The payload of the call", + "type": "array", + "items": { + "type": "integer", + "format": "uint8" + } + } + } } } } diff --git a/src/compat/crypto.rs b/src/compat/crypto.rs index d102f27..aec0994 100644 --- a/src/compat/crypto.rs +++ b/src/compat/crypto.rs @@ -4,16 +4,22 @@ // // Copyright (c) DUSK NETWORK. All rights reserved. +use dusk_bls12_381_sign::PublicKey; use dusk_bytes::Serializable; -use dusk_jubjub::{BlsScalar, JubJubScalar, JubJubAffine}; -use phoenix_core::{Note, Crossover, Fee, transaction::*}; -use dusk_schnorr::{ Signature}; -use dusk_pki::{Ownable, SecretKey as SchnorrKey}; use dusk_bytes::Write; +use dusk_jubjub::{BlsScalar, JubJubAffine, JubJubScalar}; +use dusk_pki::{Ownable, SecretKey as SchnorrKey}; +use dusk_schnorr::Signature; +use phoenix_core::{transaction::*, Crossover, Fee, Note}; use alloc::vec::Vec; -use crate::{key::{self, derive_ssk}, types, utils, MAX_KEY, MAX_LEN}; +use crate::{ + key::{self, derive_sk, derive_ssk}, + types::{self}, + utils::{self, bs58_to_psk}, + MAX_KEY, MAX_LEN, +}; const STCT_INPUT_SIZE: usize = Fee::SIZE + Crossover::SIZE @@ -143,9 +149,17 @@ pub fn unspent_spent_notes(args: i32, len: i32) -> i64 { #[no_mangle] pub fn get_stct_proof(args: i32, len: i32) -> i64 { - let type::CrossoverFeeArgs { rng_seed, seed, refund, value, sender_index, gas_limit, gas_price } = match utils::take_args(args, len) { + let types::GetStctProofArgs { + rng_seed, + seed, + refund, + value, + sender_index, + gas_limit, + gas_price, + } = match utils::take_args(args, len) { Some(a) => a, - None => return utils::fail() + None => return utils::fail(), }; let rng_seed = match utils::sanitize_seed(rng_seed) { @@ -158,38 +172,40 @@ pub fn get_stct_proof(args: i32, len: i32) -> i64 { None => return utils::fail(), }; - let sender = derive_ssk(&seed, sender_index); + let refund = match bs58_to_psk(&refund) { + Some(a) => a, + None => return utils::fail(), + }; let rng = &mut utils::rng(&rng_seed); let blinder = JubJubScalar::random(rng); - let note = Note::obfuscated(rng, refund, value, blinder); - let (mut fee, crossover) = note - .try_into() - .expect("Obfuscated notes should always yield crossovers"); + let note = Note::obfuscated(rng, &refund, value, blinder); + let (mut fee, crossover) = note + .try_into() + .expect("Obfuscated notes should always yield crossovers"); - let contract_id = rusk_abi::STAKE_CONTRACT; - let address = rusk_abi::contract_to_scalar(&contract_id); + let contract_id = rusk_abi::STAKE_CONTRACT; + let address = rusk_abi::contract_to_scalar(&contract_id); - let contract_id = rusk_abi::contract_to_scalar(&contract_id); + let contract_id = rusk_abi::contract_to_scalar(&contract_id); - let stct_message = - stct_signature_message(&crossover, value, contract_id); - let stct_message = dusk_poseidon::sponge::hash(&stct_message); + let stct_message = stct_signature_message(&crossover, value, contract_id); + let stct_message = dusk_poseidon::sponge::hash(&stct_message); - let sk_r = *sender.sk_r(fee.stealth_address()).as_ref(); - let secret = SchnorrKey::from(sk_r); + let sk_r = *sender.sk_r(fee.stealth_address()).as_ref(); + let secret = SchnorrKey::from(sk_r); - fee.gas_limit = gas_limit; - fee.gas_price = gas_price; + fee.gas_limit = gas_limit; + fee.gas_price = gas_price; - let stct_signature = Signature::new(&secret, rng, stct_message); + let stct_signature = Signature::new(&secret, rng, stct_message); - fn get_buf(fee: Fee, crossover: Crossover, value: u64, blinder: JubJubScalar, address: BlsScalar, stct_signature: Signature) -> Option<[u8; STCT_INPUT_SIZE]> { - let mut buf = [0; STCT_INPUT_SIZE]; - let mut writer = &mut buf[..]; + let mut buf = [0; STCT_INPUT_SIZE]; + let mut writer = &mut buf[..]; + let mut bytes = || { writer.write(&fee.to_bytes()).ok()?; writer.write(&crossover.to_bytes()).ok()?; writer.write(&value.to_bytes()).ok()?; @@ -198,15 +214,59 @@ pub fn get_stct_proof(args: i32, len: i32) -> i64 { writer.write(&stct_signature.to_bytes()).ok()?; Some(buf) - } + }; - let buf = match get_buf(fee, crossover, value, blinder, address, stct_signature) { - Some(a) => a, - None => return utils::fail(), - }; + let bytes = match bytes() { + Some(a) => a, + None => return utils::fail(), + } + .to_vec(); + + let signature = match rkyv::to_bytes(&stct_signature) { + Ok(a) => a.to_vec(), + Err(_) => return utils::fail(), + }; - utils::into_ptr(types::CrossoverFeeArgsResponse { - buffer: buf - }) + utils::into_ptr(types::GetStctProofResponse { bytes, signature }) +} + +pub fn get_stake_call_data(args: i32, len: i32) -> i64 { + let types::GetStakeCallDataArgs { + staker_index, + seed, + spend_proof, + value, + signature, + } = match utils::take_args(args, len) { + Some(a) => a, + None => return utils::fail(), + }; -} \ No newline at end of file + let seed = match utils::sanitize_seed(seed) { + Some(s) => s, + None => return utils::fail(), + }; + + let sk = derive_sk(&seed, staker_index); + let pk = PublicKey::from(&sk); + + let stake = Stake { + public_key: pk, + signature, + value, + proof: spend_proof, + }; + + let contract = bs58::encode(rusk_abi::STAKE_CONTRACT).into_string(); + let method = "stake"; + let payload = match rkyv::to_bytes::<_, MAX_LEN>(&stake).ok() { + Some(a) => a.to_vec(), + None => return utils::fail(), + }; + + utils::into_ptr(types::GetStakeCallDataResponse { + contract, + method, + payload, + }) +} diff --git a/src/types.rs b/src/types.rs index 0648205..c7641fc 100644 --- a/src/types.rs +++ b/src/types.rs @@ -140,6 +140,56 @@ pub struct GetMnemonicSeedResponse { #[doc = " Seed bytes from the given passphrase and Mnemonic"] pub mnemonic_seed: Vec, } +#[doc = " Get the call data for stakeing"] +#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)] +pub struct GetStakeCallDataArgs { + #[doc = " The seed to generate the sender keys from"] + pub seed: Vec, + #[doc = " The signature of the stct proof"] + pub signature: Vec, + #[doc = " The stct proof as recieved from the node"] + pub spend_proof: Vec, + #[doc = " Index of the address of the staker in the seed"] + pub staker_index: u64, + #[doc = " The amount of value to stake"] + pub value: u64, +} +#[doc = " Response of the get_stake_call_data function, send this to the call_data in execute"] +#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)] +pub struct GetStakeCallDataResponse { + #[doc = " The contract to call encoded in bs58 format"] + pub contract: String, + #[doc = " The method to call on the contract"] + pub method: String, + #[doc = " The payload of the call"] + pub payload: Vec, +} +#[doc = " Get the bytes for the stct proof to send to the node"] +#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)] +pub struct GetStctProofArgs { + #[doc = " The gas limit of the transaction"] + pub gas_limit: u64, + #[doc = " The gas price of the transaction"] + pub gas_price: u64, + #[doc = " The refund address in base58 format"] + pub refund: String, + #[doc = " The rng seed to generate the entropy for the notes"] + pub rng_seed: Vec, + #[doc = " The seed to generate the sender keys from"] + pub seed: Vec, + #[doc = " index of the sender in the seed"] + pub sender_index: u64, + #[doc = " The amount of value to send"] + pub value: u64, +} +#[doc = " Response of the get_stct_proof function"] +#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)] +pub struct GetStctProofResponse { + #[doc = " The bytes of the stct proof to send to the node"] + pub bytes: Vec, + #[doc = " The signature of the stct proof"] + pub signature: Vec, +} #[doc = " The arguments of the merge_notes function"] #[derive(Clone, PartialEq, Debug, Deserialize, Serialize)] pub struct MergeNotesArgs {