logos-blockchain/lez-programs
1
0
Fork 0
mirror of https://github.com/logos-blockchain/lez-programs.git synced 2026-08-26 06:31:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: update to release set v0.2.1

Browse Source
This commit is contained in:
r4bbit
2026-08-25 12:49:19 +02:00
parent 3994ba3055
commit 730053dcc7
63 changed files with 25164 additions and 12571 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/shared/wallet/tests/cpp/LogosWalletProviderTest.cpp
+58 -58
View File
@@ -64,16 +64,16 @@ private slots:
void LogosWalletProviderTest::adoptsOpenWalletAndCachesSnapshots()
{
LogosModules modules;
modules.logos_execution_zone.sequencerAddress = QStringLiteral("http://sequencer");
modules.logos_execution_zone.currentBlockHeight = 12;
modules.logos_execution_zone.lastSyncedBlock = 11;
modules.logos_execution_zone.accounts = {
modules.lez_core.sequencerAddress = QStringLiteral("http://sequencer");
modules.lez_core.currentBlockHeight = 12;
modules.lez_core.lastSyncedBlock = 11;
modules.lez_core.accounts = {
accountEntry(ACCOUNT_A, true),
accountEntry(ACCOUNT_B, false),
};
modules.logos_execution_zone.publicAccounts.insert(
modules.lez_core.publicAccounts.insert(
ACCOUNT_A, publicAccountJson());
modules.logos_execution_zone.balances.insert(ACCOUNT_B, QStringLiteral("42"));
modules.lez_core.balances.insert(ACCOUNT_B, QStringLiteral("42"));
LogosWalletProvider provider(&modules);
const WalletSession session = provider.connect({ QStringLiteral("unused"), QStringLiteral("unused") });
@@ -87,25 +87,25 @@ void LogosWalletProviderTest::adoptsOpenWalletAndCachesSnapshots()
QCOMPARE(session.snapshot.currentBlockHeight, quint64(12));
QCOMPARE(session.snapshot.lastSyncedBlock, quint64(11));
const int listCalls = modules.logos_execution_zone.listCalls;
const int readCalls = modules.logos_execution_zone.publicReadCalls;
const int listCalls = modules.lez_core.listCalls;
const int readCalls = modules.lez_core.publicReadCalls;
QVERIFY(provider.snapshot().ok());
QCOMPARE(modules.logos_execution_zone.listCalls, listCalls);
QCOMPARE(modules.logos_execution_zone.publicReadCalls, readCalls);
QCOMPARE(modules.lez_core.listCalls, listCalls);
QCOMPARE(modules.lez_core.publicReadCalls, readCalls);
QVERIFY(provider.snapshot(true).ok());
QVERIFY(modules.logos_execution_zone.listCalls > listCalls);
QVERIFY(modules.logos_execution_zone.publicReadCalls > readCalls);
QVERIFY(modules.lez_core.listCalls > listCalls);
QVERIFY(modules.lez_core.publicReadCalls > readCalls);
modules.logos_execution_zone.publicAccounts[ACCOUNT_A] = publicAccountJson(
modules.lez_core.publicAccounts[ACCOUNT_A] = publicAccountJson(
PROGRAM_ID, QString(32, QLatin1Char('f')));
QCOMPARE(provider.snapshot(true).accounts.at(0).balance,
QStringLiteral("340282366920938463463374607431768211455"));
provider.clearSnapshot();
const int afterRefresh = modules.logos_execution_zone.listCalls;
const int afterRefresh = modules.lez_core.listCalls;
QVERIFY(provider.snapshot().ok());
QVERIFY(modules.logos_execution_zone.listCalls > afterRefresh);
QVERIFY(modules.lez_core.listCalls > afterRefresh);
provider.disconnect();
QCOMPARE(provider.snapshot().failure, WalletFailure::WalletUnavailable);
@@ -129,8 +129,8 @@ void LogosWalletProviderTest::opensConfiguredWalletWhenNoSharedSessionExists()
QVERIFY(session.ok());
QVERIFY(!session.adopted);
QCOMPARE(modules.logos_execution_zone.openCalls, 1);
QCOMPARE(modules.logos_execution_zone.openedStorage, storage);
QCOMPARE(modules.lez_core.openCalls, 1);
QCOMPARE(modules.lez_core.openedStorage, storage);
LogosModules missingModules;
LogosWalletProvider missingProvider(&missingModules);
@@ -152,30 +152,30 @@ void LogosWalletProviderTest::createsAndPersistsWallet()
const WalletCreation creation = provider.createWallet(paths, QStringLiteral("secret"));
QVERIFY(creation.ok());
QCOMPARE(creation.mnemonic, modules.logos_execution_zone.mnemonic);
QCOMPARE(modules.logos_execution_zone.createdConfig, paths.config);
QCOMPARE(modules.logos_execution_zone.createdStorage, paths.storage);
QCOMPARE(modules.logos_execution_zone.createdPassword, QStringLiteral("secret"));
QVERIFY(modules.logos_execution_zone.saveCalls >= 1);
QCOMPARE(creation.mnemonic, modules.lez_core.mnemonic);
QCOMPARE(modules.lez_core.createdConfig, paths.config);
QCOMPARE(modules.lez_core.createdStorage, paths.storage);
QCOMPARE(modules.lez_core.createdPassword, QStringLiteral("secret"));
QVERIFY(modules.lez_core.saveCalls >= 1);
LogosModules rejectedModules;
rejectedModules.logos_execution_zone.mnemonic.clear();
rejectedModules.lez_core.mnemonic.clear();
LogosWalletProvider rejectedProvider(&rejectedModules);
QCOMPARE(rejectedProvider.createWallet(paths, QStringLiteral("secret")).failure,
WalletFailure::CreateFailed);
LogosModules unsavedModules;
unsavedModules.logos_execution_zone.saveResult = 1;
unsavedModules.lez_core.saveResult = 1;
LogosWalletProvider unsavedProvider(&unsavedModules);
const WalletCreation unsaved = unsavedProvider.createWallet(paths, QStringLiteral("secret"));
QCOMPARE(unsaved.failure, WalletFailure::SaveFailed);
QCOMPARE(unsaved.mnemonic, unsavedModules.logos_execution_zone.mnemonic);
QCOMPARE(unsaved.mnemonic, unsavedModules.lez_core.mnemonic);
}
void LogosWalletProviderTest::validatesCompletePublicAccountPayloads()
{
LogosModules modules;
modules.logos_execution_zone.publicAccounts.insert(ACCOUNT_A, publicAccountJson());
modules.lez_core.publicAccounts.insert(ACCOUNT_A, publicAccountJson());
LogosWalletProvider provider(&modules);
const WalletAccountRead valid = provider.readPublicAccount(ACCOUNT_A);
@@ -185,16 +185,16 @@ void LogosWalletProviderTest::validatesCompletePublicAccountPayloads()
QCOMPARE(valid.balanceHex, QStringLiteral("01000000000000000000000000000000"));
QCOMPARE(valid.dataHex, QStringLiteral("00ff"));
modules.logos_execution_zone.publicAccounts[ACCOUNT_A] = publicAccountJson(PROGRAM_ID.toUpper());
modules.lez_core.publicAccounts[ACCOUNT_A] = publicAccountJson(PROGRAM_ID.toUpper());
QVERIFY(!provider.readPublicAccount(ACCOUNT_A).ok());
modules.logos_execution_zone.publicAccounts[ACCOUNT_A] = publicAccountJson(
modules.lez_core.publicAccounts[ACCOUNT_A] = publicAccountJson(
PROGRAM_ID, QStringLiteral("01"));
QVERIFY(!provider.readPublicAccount(ACCOUNT_A).ok());
modules.logos_execution_zone.publicAccounts[ACCOUNT_A] = publicAccountJson(
modules.lez_core.publicAccounts[ACCOUNT_A] = publicAccountJson(
PROGRAM_ID, QStringLiteral("01000000000000000000000000000000"),
QString(32, QLatin1Char('0')), QStringLiteral("abc"));
QVERIFY(!provider.readPublicAccount(ACCOUNT_A).ok());
modules.logos_execution_zone.publicAccounts[ACCOUNT_A] = QStringLiteral("[]");
modules.lez_core.publicAccounts[ACCOUNT_A] = QStringLiteral("[]");
QVERIFY(!provider.readPublicAccount(ACCOUNT_A).ok());
QVERIFY(!provider.readPublicAccount(QStringLiteral("invalid")).ok());
}
@@ -202,9 +202,9 @@ void LogosWalletProviderTest::validatesCompletePublicAccountPayloads()
void LogosWalletProviderTest::fallsBackToBalanceWhenPublicReadFails()
{
LogosModules modules;
modules.logos_execution_zone.sequencerAddress = QStringLiteral("http://sequencer");
modules.logos_execution_zone.accounts = { accountEntry(ACCOUNT_A, true) };
modules.logos_execution_zone.balances.insert(ACCOUNT_A, QStringLiteral("42"));
modules.lez_core.sequencerAddress = QStringLiteral("http://sequencer");
modules.lez_core.accounts = { accountEntry(ACCOUNT_A, true) };
modules.lez_core.balances.insert(ACCOUNT_A, QStringLiteral("42"));
LogosWalletProvider provider(&modules);
const WalletSession session = provider.connect({});
@@ -219,32 +219,32 @@ void LogosWalletProviderTest::fallsBackToBalanceWhenPublicReadFails()
void LogosWalletProviderTest::createsAndPersistsAccounts()
{
LogosModules modules;
modules.logos_execution_zone.sequencerAddress = QStringLiteral("http://sequencer");
modules.logos_execution_zone.publicAccountId = ACCOUNT_A;
modules.logos_execution_zone.accounts = { accountEntry(ACCOUNT_A, true) };
modules.logos_execution_zone.publicAccounts.insert(ACCOUNT_A, publicAccountJson());
modules.lez_core.sequencerAddress = QStringLiteral("http://sequencer");
modules.lez_core.publicAccountId = ACCOUNT_A;
modules.lez_core.accounts = { accountEntry(ACCOUNT_A, true) };
modules.lez_core.publicAccounts.insert(ACCOUNT_A, publicAccountJson());
LogosWalletProvider provider(&modules);
QVERIFY(provider.connect({}).ok());
const int savesBeforeCreate = modules.logos_execution_zone.saveCalls;
const int savesBeforeCreate = modules.lez_core.saveCalls;
const WalletAccountCreation creation = provider.createAccount(true);
QVERIFY(creation.ok());
QCOMPARE(creation.accountId, ACCOUNT_A);
QVERIFY(creation.publicAccount.ok());
QCOMPARE(creation.snapshot.accounts.size(), 1);
QVERIFY(modules.logos_execution_zone.saveCalls > savesBeforeCreate);
QVERIFY(modules.lez_core.saveCalls > savesBeforeCreate);
modules.logos_execution_zone.saveResult = 1;
modules.lez_core.saveResult = 1;
QCOMPARE(provider.createAccount(true).failure, WalletFailure::SaveFailed);
}
void LogosWalletProviderTest::preservesCreatedAccountWhenPublicReadFails()
{
LogosModules modules;
modules.logos_execution_zone.sequencerAddress = QStringLiteral("http://sequencer");
modules.logos_execution_zone.publicAccountId = ACCOUNT_A;
modules.logos_execution_zone.accounts = { accountEntry(ACCOUNT_A, true) };
modules.logos_execution_zone.balances.insert(ACCOUNT_A, QStringLiteral("7"));
modules.lez_core.sequencerAddress = QStringLiteral("http://sequencer");
modules.lez_core.publicAccountId = ACCOUNT_A;
modules.lez_core.accounts = { accountEntry(ACCOUNT_A, true) };
modules.lez_core.balances.insert(ACCOUNT_A, QStringLiteral("7"));
LogosWalletProvider provider(&modules);
QVERIFY(provider.connect({}).ok());
@@ -260,14 +260,14 @@ void LogosWalletProviderTest::preservesCreatedAccountWhenPublicReadFails()
void LogosWalletProviderTest::preservesCreatedAccountWhenSnapshotRefreshFails()
{
LogosModules modules;
modules.logos_execution_zone.sequencerAddress = QStringLiteral("http://sequencer");
modules.logos_execution_zone.publicAccountId = ACCOUNT_A;
modules.logos_execution_zone.publicAccounts.insert(ACCOUNT_A, publicAccountJson());
modules.lez_core.sequencerAddress = QStringLiteral("http://sequencer");
modules.lez_core.publicAccountId = ACCOUNT_A;
modules.lez_core.publicAccounts.insert(ACCOUNT_A, publicAccountJson());
LogosWalletProvider provider(&modules);
QVERIFY(provider.connect({}).ok());
modules.logos_execution_zone.currentBlockHeight = 1;
modules.logos_execution_zone.syncResult = 1;
modules.lez_core.currentBlockHeight = 1;
modules.lez_core.syncResult = 1;
const WalletAccountCreation creation = provider.createAccount(true);
QVERIFY(creation.ok());
@@ -278,8 +278,8 @@ void LogosWalletProviderTest::preservesCreatedAccountWhenSnapshotRefreshFails()
void LogosWalletProviderTest::dispatchesExactGenericTransaction()
{
LogosModules modules;
modules.logos_execution_zone.sequencerAddress = QStringLiteral("http://sequencer");
modules.logos_execution_zone.transactionResponse = QStringLiteral(
modules.lez_core.sequencerAddress = QStringLiteral("http://sequencer");
modules.lez_core.transactionResponse = QStringLiteral(
R"({"success":true,"tx_hash":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"})");
LogosWalletProvider provider(&modules);
QVERIFY(provider.connect({}).ok());
@@ -293,19 +293,19 @@ void LogosWalletProviderTest::dispatchesExactGenericTransaction()
const WalletSubmission submission = provider.submitPublicTransaction(transaction);
QVERIFY(submission.accepted());
QCOMPARE(submission.nativeHash, QString(64, QLatin1Char('a')));
QCOMPARE(modules.logos_execution_zone.submitCalls, 1);
QCOMPARE(modules.logos_execution_zone.submittedProgramId, PROGRAM_ID);
QCOMPARE(modules.logos_execution_zone.submittedAccountIds, transaction.accountIds);
QCOMPARE(modules.logos_execution_zone.submittedSigningRequirements,
QCOMPARE(modules.lez_core.submitCalls, 1);
QCOMPARE(modules.lez_core.submittedProgramId, PROGRAM_ID);
QCOMPARE(modules.lez_core.submittedAccountIds, transaction.accountIds);
QCOMPARE(modules.lez_core.submittedSigningRequirements,
QVariantList({ true, false }));
QCOMPARE(modules.logos_execution_zone.submittedInstruction.toList(),
QCOMPARE(modules.lez_core.submittedInstruction.toList(),
QVariantList({ 7U, 0U, 4294967295U }));
}
void LogosWalletProviderTest::rejectsInvalidSubmissionResponses()
{
LogosModules modules;
modules.logos_execution_zone.sequencerAddress = QStringLiteral("http://sequencer");
modules.lez_core.sequencerAddress = QStringLiteral("http://sequencer");
LogosWalletProvider provider(&modules);
QVERIFY(provider.connect({}).ok());
@@ -323,7 +323,7 @@ void LogosWalletProviderTest::rejectsInvalidSubmissionResponses()
QStringLiteral(R"({"success":true,"tx_hash":"short"})"),
};
for (const QString& response : invalidResponses) {
modules.logos_execution_zone.transactionResponse = response;
modules.lez_core.transactionResponse = response;
QCOMPARE(provider.submitPublicTransaction(transaction).failure,
WalletFailure::SubmissionFailed);
}