logos-blockchain/logos-execution-zone-module
1
0
Fork 0
mirror of https://github.com/logos-blockchain/logos-execution-zone-module.git synced 2026-08-04 09:13:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #43 from logos-blockchain/schouhy/bump-lez-version

Browse Source 
chore: bump lez version
This commit is contained in:
Moudy 2026-08-03 10:37:57 +02:00 committed by GitHub
commit d6b69f59f2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 109 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
flake.lock generated
View File

@ -2716,17 +2716,17 @@
"rust-rapidsnark": "rust-rapidsnark"
},
"locked": {
"lastModified": 1782922431,
"narHash": "sha256-loCudmjk5qD12UqgiS7lyUc2UpTDzNpH1y0e8qojkNs=",
"lastModified": 1785659324,
"narHash": "sha256-xtC9Qksgp3f3ZEDdhLuM0DegelFl4EW20jqSmhqHeHQ=",
"owner": "logos-blockchain",
"repo": "logos-execution-zone",
"rev": "571f35b3849c889f893109fd2b9dad040f0a3b57",
"rev": "15144ddb8437f48cdce32908e122dbb7eea68399",
"type": "github"
},
"original": {
"owner": "logos-blockchain",
"ref": "v0.2.1",
"repo": "logos-execution-zone",
"rev": "571f35b3849c889f893109fd2b9dad040f0a3b57",
"type": "github"
}
},

2
flake.nix
View File

@ -4,7 +4,7 @@
inputs = {
logos-module-builder.url = "github:logos-co/logos-module-builder";
nix-bundle-lgx.url = "github:logos-co/nix-bundle-lgx";
logos-execution-zone.url = "github:logos-blockchain/logos-execution-zone?rev=571f35b3849c889f893109fd2b9dad040f0a3b57";
logos-execution-zone.url = "github:logos-blockchain/logos-execution-zone?ref=v0.2.1";
};
outputs = inputs@{ logos-module-builder, ... }:

40
src/lez_core_module.cpp
View File

@ -212,28 +212,31 @@ bool jsonToFfiPrivateAccountKeys(const std::string& json, FfiPrivateAccountKeys*
if (doc.is_discarded() || !doc.is_object())
return false;
if (doc.contains(JsonKeys::NullifierPublicKey) && doc[JsonKeys::NullifierPublicKey].is_string()) {
if (!hexToBytes32(doc[JsonKeys::NullifierPublicKey].get<std::string>(), &output_keys->nullifier_public_key))
return false;
}
// Nullifier public key is mandatory: a missing/wrong-typed value must not fall back to zero.
if (!doc.contains(JsonKeys::NullifierPublicKey) || !doc[JsonKeys::NullifierPublicKey].is_string())
return false;
if (!hexToBytes32(doc[JsonKeys::NullifierPublicKey].get<std::string>(), &output_keys->nullifier_public_key))
return false;
output_keys->viewing_public_key = nullptr;
output_keys->viewing_public_key_len = 0;
if (doc.contains(JsonKeys::ViewingPublicKey)) {
if (!doc[JsonKeys::ViewingPublicKey].is_string())
return false;
if (doc.contains(JsonKeys::ViewingPublicKey) && doc[JsonKeys::ViewingPublicKey].is_string()) {
std::vector<uint8_t> buffer;
if (!hexToBytes(doc[JsonKeys::ViewingPublicKey].get<std::string>(), buffer))
return false;
if (buffer.empty()) {
output_keys->viewing_public_key = nullptr;
output_keys->viewing_public_key_len = 0;
} else {
if (!buffer.empty()) {
auto* data = static_cast<uint8_t*>(malloc(buffer.size()));
if (!data)
return false;
memcpy(data, buffer.data(), buffer.size());
output_keys->viewing_public_key = data;
output_keys->viewing_public_key_len = buffer.size();
}
} else {
output_keys->viewing_public_key = nullptr;
output_keys->viewing_public_key_len = 0;
}
return true;
@ -924,7 +927,7 @@ std::vector<uint8_t> LEZCoreModule::token_elf() {
std::vector<uint8_t> LEZCoreModule::amm_elf() {
FfiProgram ffi_program{};
WalletFfiError error = wallet_ffi_token_elf(&ffi_program);
WalletFfiError error = wallet_ffi_amm_elf(&ffi_program);
if (error != SUCCESS) {
fprintf(stderr, "amm_elf: wallet FFI error %d\n", error);
return std::vector<uint8_t>{};
@ -939,7 +942,7 @@ std::vector<uint8_t> LEZCoreModule::amm_elf() {
std::vector<uint8_t> LEZCoreModule::ata_elf() {
FfiProgram ffi_program{};
WalletFfiError error = wallet_ffi_token_elf(&ffi_program);
WalletFfiError error = wallet_ffi_ata_elf(&ffi_program);
if (error != SUCCESS) {
fprintf(stderr, "ata_elf: wallet FFI error %d\n", error);
return std::vector<uint8_t>{};
@ -954,7 +957,7 @@ std::vector<uint8_t> LEZCoreModule::ata_elf() {
std::vector<uint8_t> LEZCoreModule::authenticated_transfer_elf() {
FfiProgram ffi_program{};
WalletFfiError error = wallet_ffi_token_elf(&ffi_program);
WalletFfiError error = wallet_ffi_transfer_elf(&ffi_program);
if (error != SUCCESS) {
fprintf(stderr, "authenticated_transfer_elf: wallet FFI error %d\n", error);
return std::vector<uint8_t>{};
@ -1150,6 +1153,7 @@ std::string LEZCoreModule::send_program_deployment_transaction(
std::string LEZCoreModule::create_new(
const std::string& config_path,
const std::string& storage_path,
const std::string& statistics_path,
const std::string& password
) {
if (walletHandle) {
@ -1157,7 +1161,7 @@ std::string LEZCoreModule::create_new(
return {};
}
FfiCreateWalletOutput create_output = wallet_ffi_create_new(config_path.c_str(), storage_path.c_str(), password.c_str());
FfiCreateWalletOutput create_output = wallet_ffi_create_new(config_path.c_str(), storage_path.c_str(), statistics_path.c_str(), password.c_str());
if (!create_output.wallet) {
fprintf(stderr, "create_new: wallet_ffi_create_new returned null\n");
return {};
@ -1181,13 +1185,13 @@ int64_t LEZCoreModule::restore_storage(const std::string& mnemonic, const std::s
return SUCCESS;
}
int64_t LEZCoreModule::open(const std::string& config_path, const std::string& storage_path) {
int64_t LEZCoreModule::open(const std::string& config_path, const std::string& storage_path, const std::string& statistics_path) {
if (walletHandle) {
fprintf(stderr, "open: wallet is already open\n");
return INTERNAL_ERROR;
}
walletHandle = wallet_ffi_open(config_path.c_str(), storage_path.c_str());
walletHandle = wallet_ffi_open(config_path.c_str(), storage_path.c_str(), statistics_path.c_str());
if (!walletHandle) {
fprintf(stderr, "open: wallet_ffi_open returned null\n");
return INTERNAL_ERROR;

4
src/lez_core_module.h
View File

@ -30,8 +30,8 @@ public:
std::string version() const;
// === Wallet Lifecycle ===
std::string create_new(const std::string& config_path, const std::string& storage_path, const std::string& password);
int64_t open(const std::string& config_path, const std::string& storage_path);
std::string create_new(const std::string& config_path, const std::string& storage_path, const std::string& statistics_path, const std::string& password);
int64_t open(const std::string& config_path, const std::string& storage_path, const std::string& statistics_path);
int64_t save();
int64_t restore_storage(const std::string& mnemonic, const std::string password, uint32_t depth);

4
tests/mocks/mock_wallet_ffi.cpp
View File

@ -54,7 +54,7 @@ extern "C" {
// === Lifecycle ===
FfiCreateWalletOutput wallet_ffi_create_new(const char*, const char*, const char*) {
FfiCreateWalletOutput wallet_ffi_create_new(const char*, const char*, const char*, const char*) {
LOGOS_CMOCK_RECORD("wallet_ffi_create_new");
const int ok = LOGOS_CMOCK_RETURN(int, "wallet_ffi_create_new");
const char* mnemonic_ok = LOGOS_CMOCK_RETURN_STRING("wallet_ffi_create_new");
@ -65,7 +65,7 @@ FfiCreateWalletOutput wallet_ffi_create_new(const char*, const char*, const char
return output;
}
WalletHandle* wallet_ffi_open(const char*, const char*) {
WalletHandle* wallet_ffi_open(const char*, const char*, const char*) {
LOGOS_CMOCK_RECORD("wallet_ffi_open");
const int ok = LOGOS_CMOCK_RETURN(int, "wallet_ffi_open");
return ok ? reinterpret_cast<WalletHandle*>(&g_fakeWallet) : nullptr;

4
tests/stubs/wallet_ffi.h
View File

@ -191,8 +191,8 @@ typedef struct LabelList {
// === Lifecycle ===
FfiCreateWalletOutput wallet_ffi_create_new(const char* config_path, const char* storage_path, const char* password);
WalletHandle* wallet_ffi_open(const char* config_path, const char* storage_path);
FfiCreateWalletOutput wallet_ffi_create_new(const char* config_path, const char* storage_path, const char* statistics_path, const char* password);
WalletHandle* wallet_ffi_open(const char* config_path, const char* storage_path, const char* statistics_path);
int wallet_ffi_save(WalletHandle* handle);
void wallet_ffi_destroy(WalletHandle* handle);

80
tests/test_lez_core.cpp
View File

@ -288,6 +288,68 @@ LOGOS_TEST(transfer_shielded_invalid_keys_json_error) {
LOGOS_ASSERT_FALSE(t.cFunctionCalled("wallet_ffi_transfer_shielded"));
}
// A missing nullifier_public_key must not succeed with a zero key.
LOGOS_TEST(transfer_shielded_missing_nullifier_key_error) {
auto t = LogosTestContext("logos_execution_zone");
LEZCoreModule module;
const nlohmann::json obj = parseObject(module.transfer_shielded(VALID_ID, "{}", VALID_U128));
LOGOS_ASSERT_FALSE(obj["success"].get<bool>());
LOGOS_ASSERT_FALSE(t.cFunctionCalled("wallet_ffi_transfer_shielded"));
}
LOGOS_TEST(transfer_shielded_misspelled_nullifier_key_error) {
auto t = LogosTestContext("logos_execution_zone");
LEZCoreModule module;
const std::string keysJson = std::string("{\"nullifierPublicKey\":\"") + std::string(64, 'a') + "\"}";
const nlohmann::json obj = parseObject(module.transfer_shielded(VALID_ID, keysJson, VALID_U128));
LOGOS_ASSERT_FALSE(obj["success"].get<bool>());
LOGOS_ASSERT_FALSE(t.cFunctionCalled("wallet_ffi_transfer_shielded"));
}
LOGOS_TEST(transfer_shielded_abbreviated_nullifier_key_error) {
auto t = LogosTestContext("logos_execution_zone");
LEZCoreModule module;
const std::string keysJson = std::string("{\"nullifier_pubkey\":\"") + std::string(64, 'a') + "\"}";
const nlohmann::json obj = parseObject(module.transfer_shielded(VALID_ID, keysJson, VALID_U128));
LOGOS_ASSERT_FALSE(obj["success"].get<bool>());
LOGOS_ASSERT_FALSE(t.cFunctionCalled("wallet_ffi_transfer_shielded"));
}
LOGOS_TEST(transfer_shielded_nullifier_key_omitted_viewing_key_only_error) {
auto t = LogosTestContext("logos_execution_zone");
LEZCoreModule module;
const std::string keysJson = std::string("{\"viewing_public_key\":\"") + std::string(64, 'a') + "\"}";
const nlohmann::json obj = parseObject(module.transfer_shielded(VALID_ID, keysJson, VALID_U128));
LOGOS_ASSERT_FALSE(obj["success"].get<bool>());
LOGOS_ASSERT_FALSE(t.cFunctionCalled("wallet_ffi_transfer_shielded"));
}
LOGOS_TEST(transfer_shielded_nullifier_key_wrong_type_error) {
auto t = LogosTestContext("logos_execution_zone");
LEZCoreModule module;
const std::string keysJson = "{\"nullifier_public_key\": 12345}";
const nlohmann::json obj = parseObject(module.transfer_shielded(VALID_ID, keysJson, VALID_U128));
LOGOS_ASSERT_FALSE(obj["success"].get<bool>());
LOGOS_ASSERT_FALSE(t.cFunctionCalled("wallet_ffi_transfer_shielded"));
}
// A non-string viewing_public_key must be rejected, not treated as absent.
LOGOS_TEST(transfer_shielded_viewing_key_wrong_type_error) {
auto t = LogosTestContext("logos_execution_zone");
LEZCoreModule module;
const std::string keysJson = std::string("{\"nullifier_public_key\":\"") + std::string(64, 'a')
+ "\",\"viewing_public_key\": 12345}";
const nlohmann::json obj = parseObject(module.transfer_shielded(VALID_ID, keysJson, VALID_U128));
LOGOS_ASSERT_FALSE(obj["success"].get<bool>());
LOGOS_ASSERT_FALSE(t.cFunctionCalled("wallet_ffi_transfer_shielded"));
}
LOGOS_TEST(transfer_shielded_success_json) {
auto t = LogosTestContext("logos_execution_zone");
LEZCoreModule module;
@ -335,6 +397,16 @@ LOGOS_TEST(transfer_shielded_without_identifier_uses_random_nonzero_identifier)
LOGOS_ASSERT_FALSE(memcmp(first, second, sizeof(first)) == 0);
}
// transfer_private shares the same parser, so it must reject a missing key too.
LOGOS_TEST(transfer_private_missing_nullifier_key_error) {
auto t = LogosTestContext("logos_execution_zone");
LEZCoreModule module;
const nlohmann::json obj = parseObject(module.transfer_private(VALID_ID, "{}", VALID_U128));
LOGOS_ASSERT_FALSE(obj["success"].get<bool>());
LOGOS_ASSERT_FALSE(t.cFunctionCalled("wallet_ffi_transfer_private"));
}
// transfer_private mirrors transfer_shielded's identifier handling exactly (see above).
LOGOS_TEST(transfer_private_with_identifier_forwards_it_unchanged) {
auto t = LogosTestContext("logos_execution_zone");
@ -590,10 +662,10 @@ LOGOS_TEST(create_new_success_then_double_open_fails) {
t.mockCFunction("wallet_ffi_create_new").returns(1); // non-null handle
LEZCoreModule module;
LOGOS_ASSERT_TRUE(!module.create_new("/cfg", "/store", "pw").empty());
LOGOS_ASSERT_TRUE(!module.create_new("/cfg", "/store", "/stats", "pw").empty());
LOGOS_ASSERT(t.cFunctionCalled("wallet_ffi_create_new"));
// Second attempt: already open.
LOGOS_ASSERT_EQ(module.create_new("/cfg", "/store", "pw"), "");
LOGOS_ASSERT_EQ(module.create_new("/cfg", "/store", "/stats", "pw"), "");
}
LOGOS_TEST(create_new_null_handle_returns_internal_error) {
@ -601,7 +673,7 @@ LOGOS_TEST(create_new_null_handle_returns_internal_error) {
t.mockCFunction("wallet_ffi_create_new").returns(0); // null handle
LEZCoreModule module;
LOGOS_ASSERT_EQ(module.create_new("/cfg", "/store", "pw"), "");
LOGOS_ASSERT_EQ(module.create_new("/cfg", "/store", "/stats", "pw"), "");
}
LOGOS_TEST(open_success) {
@ -609,7 +681,7 @@ LOGOS_TEST(open_success) {
t.mockCFunction("wallet_ffi_open").returns(1);
LEZCoreModule module;
LOGOS_ASSERT_EQ(module.open("/cfg", "/store"), static_cast<int64_t>(SUCCESS));
LOGOS_ASSERT_EQ(module.open("/cfg", "/store", "/stats"), static_cast<int64_t>(SUCCESS));
LOGOS_ASSERT(t.cFunctionCalled("wallet_ffi_open"));
}