From be59cf93179b0c2dad7e3de4b0707a00d4acb4a2 Mon Sep 17 00:00:00 2001 From: abenso Date: Fri, 8 Nov 2024 17:31:34 -0300 Subject: [PATCH] send spend action to rust --- app/rust/include/rslib.h | 2 ++ app/rust/src/parser/plans.rs | 32 ++++++++++++++++--- app/rust/src/parser/plans/spend.rs | 46 +++++++++++++++++++++++++++ app/src/parser_impl.c | 33 +++++++++++++------- app/src/parser_interface.c | 17 ++++++++++ app/src/parser_interface.h | 1 + app/src/parser_txdef.h | 10 ++++-- tests_zemu/tests/common.ts | 8 ++--- tests_zemu/tests/standard.test.ts | 50 +++++++++++++++--------------- 9 files changed, 153 insertions(+), 46 deletions(-) diff --git a/app/rust/include/rslib.h b/app/rust/include/rslib.h index 4e5a527..5248442 100644 --- a/app/rust/include/rslib.h +++ b/app/rust/include/rslib.h @@ -29,6 +29,8 @@ parser_error_t rs_compute_effect_hash(); parser_error_t rs_compute_transaction_plan(transaction_plan_t *plan, uint8_t *output, size_t output_len); +parser_error_t rs_spend_action_hash(spend_plan_t *plan, uint8_t *output, size_t output_len); + int32_t rs_bech32_encode(const uint8_t *hrp_ptr, size_t hrp_len, const uint8_t *data_ptr, size_t data_len, uint8_t *output_ptr, size_t output_len); diff --git a/app/rust/src/parser/plans.rs b/app/rust/src/parser/plans.rs index 5da6a01..836a10e 100644 --- a/app/rust/src/parser/plans.rs +++ b/app/rust/src/parser/plans.rs @@ -14,9 +14,10 @@ * limitations under the License. ********************************************************************************/ use self::{ - action::ActionC, action::ActionPlan, detection::DetectionDataPlan, - detection::DetectionDataPlanC, memo::MemoPlanC, + action::ActionPlan, detection::DetectionDataPlan, + detection::DetectionDataPlanC, memo::MemoPlanC, spend::SpendPlanC, }; +use crate::parser::bytes::BytesC; use super::{ObjectList, TransactionParameters}; @@ -81,7 +82,7 @@ pub struct TransactionPlan<'a> { #[repr(C)] #[cfg_attr(any(feature = "derive-debug", test), derive(Debug))] pub struct TransactionPlanC { - pub actions: [ActionC; ACTION_DATA_QTY], + pub actions_hashes: [BytesC; ACTION_DATA_QTY], pub transaction_parameters: TransactionParametersC, pub memo: MemoPlanC, pub detection_data: DetectionDataPlanC, @@ -134,6 +135,29 @@ pub unsafe extern "C" fn rs_compute_transaction_plan( ParserError::Ok as u32 } +#[no_mangle] +/// Use to compute an address and write it back into output +/// argument. +pub unsafe extern "C" fn rs_spend_action_hash( + plan: &SpendPlanC, + output: *mut u8, + output_len: usize, +) -> u32 { + crate::zlog("rs_spend_action_hash\x00"); + let output = std::slice::from_raw_parts_mut(output, output_len); + + if output.len() < 64 { + return ParserError::Ok as u32; + } + + // TODO: implement spend hash + for byte in output.iter_mut() { + *byte = 1; + } + + ParserError::Ok as u32 +} + #[cfg(test)] mod tests { use super::*; @@ -208,7 +232,7 @@ mod tests { // Create TransactionPlanC with dummy data let transaction_plan = TransactionPlanC { - actions: core::array::from_fn(|_| dummy_action.clone()), + actions_hashes: core::array::from_fn(|_| BytesC::from_slice(&[0u8; 32])), transaction_parameters: dummy_transaction_parameters, memo: dummy_memo_plan, detection_data: dummy_detection_data, diff --git a/app/rust/src/parser/plans/spend.rs b/app/rust/src/parser/plans/spend.rs index 60d8ea6..9bb78e7 100644 --- a/app/rust/src/parser/plans/spend.rs +++ b/app/rust/src/parser/plans/spend.rs @@ -1,5 +1,7 @@ use core::{mem::MaybeUninit, ptr::addr_of_mut}; +use crate::parser::{address::AddressC, bytes::BytesC}; + use crate::{ parser::{Fq, Fr, Note, Position}, FromBytes, ParserError, @@ -65,3 +67,47 @@ impl<'b> FromBytes<'b> for SpendPlan<'b> { Ok(input) } } + +#[repr(C)] +#[derive(Clone)] +#[cfg_attr(any(feature = "derive-debug", test), derive(Debug))] +pub struct AmountC { + pub lo: u64, + pub hi: u64, +} + +#[repr(C)] +#[derive(Clone)] +#[cfg_attr(any(feature = "derive-debug", test), derive(Debug))] +pub struct AssetIdC { + pub inner: BytesC, +} + +#[repr(C)] +#[derive(Clone)] +#[cfg_attr(any(feature = "derive-debug", test), derive(Debug))] +pub struct ValueC { + pub amount: AmountC, + pub asset_id: AssetIdC, +} + +#[repr(C)] +#[derive(Clone)] +#[cfg_attr(any(feature = "derive-debug", test), derive(Debug))] +pub struct NoteC { + pub value: ValueC, + pub rseed: BytesC, + pub address: AddressC, +} + +#[repr(C)] +#[derive(Clone)] +#[cfg_attr(any(feature = "derive-debug", test), derive(Debug))] +pub struct SpendPlanC { + pub note: NoteC, + pub position: u64, + pub randomizer: BytesC, + pub value_blinding: BytesC, + pub proof_blinding_r: BytesC, + pub proof_blinding_s: BytesC, +} \ No newline at end of file diff --git a/app/src/parser_impl.c b/app/src/parser_impl.c index 221a2b6..cd27519 100644 --- a/app/src/parser_impl.c +++ b/app/src/parser_impl.c @@ -55,7 +55,6 @@ void print_string(const char *str) { bool decode_action(pb_istream_t *stream, const pb_field_t *field, void **arg) { penumbra_core_transaction_v1_ActionPlan action = penumbra_core_transaction_v1_ActionPlan_init_default; - spend_plan_t spend_plan; action_t *decode_arg = (action_t *)*arg; if (decode_arg == NULL) { @@ -66,10 +65,9 @@ bool decode_action(pb_istream_t *stream, const pb_field_t *field, void **arg) { return false; } - const uint8_t *first_byte = stream->state; - uint16_t data_size = stream->bytes_left; - decode_arg[actions_qty].action.ptr = first_byte + 3; - decode_arg[actions_qty].action.len = data_size - 3; + Bytes_t action_data; + action_data.ptr = stream->state + 3; + action_data.len = stream->bytes_left - 3; if (!pb_decode(stream, penumbra_core_transaction_v1_ActionPlan_fields, &action)) { return false; @@ -77,7 +75,7 @@ bool decode_action(pb_istream_t *stream, const pb_field_t *field, void **arg) { decode_arg[actions_qty].action_type = action.which_action; switch (action.which_action) { case penumbra_core_transaction_v1_ActionPlan_spend_tag: - decode_spend_plan(&decode_arg[actions_qty].action, &spend_plan); + decode_spend_plan(&action_data, &decode_arg[actions_qty].action.spend); print_string("Spend action detected \n"); break; case penumbra_core_transaction_v1_ActionPlan_output_tag: @@ -137,6 +135,7 @@ bool decode_detection_data(pb_istream_t *stream, const pb_field_t *field, void * parser_error_t _read(parser_context_t *c, parser_tx_t *v) { Bytes_t data; + action_t actions_plan[ACTIONS_QTY]; data.ptr = c->buffer; data.len = c->bufferLen; actions_qty = 0; @@ -156,7 +155,7 @@ parser_error_t _read(parser_context_t *c, parser_tx_t *v) { // actions callbacks request.actions.funcs.decode = &decode_action; - request.actions.arg = &v->plan.actions; + request.actions.arg = &actions_plan; // detection data callbacks request.detection_data.clue_plans.funcs.decode = &decode_detection_data; @@ -183,15 +182,21 @@ parser_error_t _read(parser_context_t *c, parser_tx_t *v) { // print detection data for (uint16_t i = 0; i < DETECTION_DATA_QTY; i++) { - print_buffer(&v->plan.detection_data.clue_plans[i].address.inner, "real detection data address inner"); - print_buffer(&v->plan.detection_data.clue_plans[i].address.alt_bech32m, "real detection data address alt bech32m"); - print_buffer(&v->plan.detection_data.clue_plans[i].rseed, "real detection data rseed"); + // print_buffer(&v->plan.detection_data.clue_plans[i].address.inner, "real detection data address inner"); + // print_buffer(&v->plan.detection_data.clue_plans[i].address.alt_bech32m, "real detection data address alt bech32m"); + // print_buffer(&v->plan.detection_data.clue_plans[i].rseed, "real detection data rseed"); // printf("precision bits: %lu\n", v->plan.detection_data.clue_plans[i].precision_bits); } // print actions for (uint16_t i = 0; i < ACTIONS_QTY; i++) { - print_buffer(&v->plan.actions[i].action, "real actions"); + switch (actions_plan[i].action_type) { + case penumbra_core_transaction_v1_ActionPlan_spend_tag: + // printf("spend action detected\n"); + // printf("amount hi: %lu\n", actions_plan[i].action.spend.note.value.amount.hi); + // printf("amount lo: %lu\n", actions_plan[i].action.spend.note.value.amount.lo); + break; + } } // print memo @@ -200,6 +205,12 @@ parser_error_t _read(parser_context_t *c, parser_tx_t *v) { print_buffer(&v->plan.memo.plaintext.return_address.inner, "real memo return address inner"); print_buffer(&v->plan.memo.plaintext.return_address.alt_bech32m, "real memo return address alt bech32m"); + for (uint16_t i = 0; i < DETECTION_DATA_QTY; i++) { + if (actions_plan[i].action_type == penumbra_core_transaction_v1_ActionPlan_spend_tag) { + compute_spend_action_hash(&actions_plan[i].action.spend); + } + } + compute_transaction_plan(&v->plan); return parser_unexpected_error; diff --git a/app/src/parser_interface.c b/app/src/parser_interface.c index fe0abfd..a554ef7 100644 --- a/app/src/parser_interface.c +++ b/app/src/parser_interface.c @@ -52,3 +52,20 @@ parser_error_t compute_transaction_plan(transaction_plan_t *plan) { return parser_ok; } + +parser_error_t compute_spend_action_hash(spend_plan_t *plan) { + if (plan == NULL) return parser_unexpected_error; + + uint8_t output[64] = {0}; + if (rs_spend_action_hash(plan, output, sizeof(output)) != parser_ok) { + return parser_unexpected_error; + } + + // TODO: only for testing + Bytes_t output_bytes; + output_bytes.ptr = output; + output_bytes.len = 64; + print_buffer_interface(&output_bytes, "spend action hash"); + + return parser_ok; +} diff --git a/app/src/parser_interface.h b/app/src/parser_interface.h index 134207c..68734c1 100644 --- a/app/src/parser_interface.h +++ b/app/src/parser_interface.h @@ -29,6 +29,7 @@ extern "C" { #include "zxmacros.h" parser_error_t compute_transaction_plan(transaction_plan_t *plan); +parser_error_t compute_spend_action_hash(spend_plan_t *plan); #ifdef __cplusplus } diff --git a/app/src/parser_txdef.h b/app/src/parser_txdef.h index 5b28627..01ffa40 100644 --- a/app/src/parser_txdef.h +++ b/app/src/parser_txdef.h @@ -102,11 +102,17 @@ typedef struct { typedef struct { uint8_t action_type; - Bytes_t action; + union { + spend_plan_t spend; + } action; } action_t; typedef struct { - action_t actions[ACTIONS_QTY]; + Bytes_t action_hash; +} action_hash_t; + +typedef struct { + action_hash_t actions_hash[ACTIONS_QTY]; transaction_parameters_t transaction_parameters; memo_plan_t memo; detection_data_t detection_data; diff --git a/tests_zemu/tests/common.ts b/tests_zemu/tests/common.ts index d574924..7dcddd7 100644 --- a/tests_zemu/tests/common.ts +++ b/tests_zemu/tests/common.ts @@ -15,10 +15,10 @@ const APP_PATH_FL = resolve('../app/output/app_flex.elf') export const models: IDeviceModel[] = [ // { name: 'nanos', prefix: 'S', path: APP_PATH_S }, - { name: 'nanox', prefix: 'X', path: APP_PATH_X }, + // { name: 'nanox', prefix: 'X', path: APP_PATH_X }, { name: 'nanosp', prefix: 'SP', path: APP_PATH_SP }, - { name: 'stax', prefix: 'ST', path: APP_PATH_ST }, - { name: 'flex', prefix: 'FL', path: APP_PATH_FL }, + // { name: 'stax', prefix: 'ST', path: APP_PATH_ST }, + // { name: 'flex', prefix: 'FL', path: APP_PATH_FL }, ] export const defaultOptions = { @@ -29,5 +29,5 @@ export const defaultOptions = { } export const txBlobExample = - '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' + '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' diff --git a/tests_zemu/tests/standard.test.ts b/tests_zemu/tests/standard.test.ts index 1bdfe0b..cd7c876 100644 --- a/tests_zemu/tests/standard.test.ts +++ b/tests_zemu/tests/standard.test.ts @@ -184,31 +184,31 @@ describe('Standard', function () { }) // TODO: WIP - // test.concurrent.each(models)('sign', async function (m) { - // const sim = new Zemu(m.path) - // try { - // await sim.start({ ...defaultOptions, model: m.name }) - // const app = new PenumbraApp(sim.getTransport()) - - // const messageToSign = Buffer.from(txBlobExample, 'hex') - // console.log("messageToSignLength!!!!!", messageToSign.length) - // console.log("messageToSign!!!!!", messageToSign) - // // do not wait here... we need to navigate - // const signatureRequest = app.sign(PEN_PATH, ACCOUNT_ID, messageToSign) - - // // Wait until we are not in the main menu - // // await sim.waitUntilScreenIsNot(sim.getMainMenuSnapshot()) - // // await sim.compareSnapshotsAndApprove('.', `${m.prefix.toLowerCase()}-sign`) + test.only.each(models)('sign', async function (m) { + const sim = new Zemu(m.path) + try { + await sim.start({ ...defaultOptions, model: m.name }) + const app = new PenumbraApp(sim.getTransport()) + + const messageToSign = Buffer.from(txBlobExample, 'hex') + console.log("messageToSignLength!!!!!", messageToSign.length) + console.log("messageToSign!!!!!", messageToSign) + // do not wait here... we need to navigate + const signatureRequest = app.sign(PEN_PATH, ACCOUNT_ID, messageToSign) + + // Wait until we are not in the main menu + // await sim.waitUntilScreenIsNot(sim.getMainMenuSnapshot()) + // await sim.compareSnapshotsAndApprove('.', `${m.prefix.toLowerCase()}-sign`) - // const signatureResponse = await signatureRequest - // console.log(signatureResponse) - - // // Now verify the signature - // // const valid = ed25519.verify(signatureResponse.signature, messageToSign, pubKey) - // // expect(valid).toEqual(true) - // } finally { - // await sim.close() - // } - // }) + const signatureResponse = await signatureRequest + console.log(signatureResponse) + + // Now verify the signature + // const valid = ed25519.verify(signatureResponse.signature, messageToSign, pubKey) + // expect(valid).toEqual(true) + } finally { + await sim.close() + } + }) })