From 293d8e4ddb39b61a66012005ca795442eec741fb Mon Sep 17 00:00:00 2001 From: Mayukha Vadari Date: Fri, 15 Aug 2025 15:32:36 -0400 Subject: [PATCH] test: store Rust source code in rippled, instead of just opaque hex strings (#5653) --- .clang-format | 3 + src/test/app/Escrow_test.cpp | 41 +- src/test/app/Wasm_test.cpp | 191 +- src/test/app/wasm_fixtures/.gitignore | 3 + .../all_host_functions/Cargo.lock | 15 + .../all_host_functions/Cargo.toml | 21 + .../all_host_functions/src/lib.rs | 828 +++++++ .../app/wasm_fixtures/all_keylets/Cargo.lock | 15 + .../app/wasm_fixtures/all_keylets/Cargo.toml | 21 + .../app/wasm_fixtures/all_keylets/src/lib.rs | 156 ++ src/test/app/wasm_fixtures/b58.c | 73 + .../wasm_fixtures/codecov_tests/Cargo.lock | 15 + .../wasm_fixtures/codecov_tests/Cargo.toml | 19 + .../codecov_tests/src/host_bindings_loose.rs | 47 + .../wasm_fixtures/codecov_tests/src/lib.rs | 953 +++++++ src/test/app/wasm_fixtures/copyFixtures.py | 130 + src/test/app/wasm_fixtures/disableFloat.wat | 34 + src/test/app/wasm_fixtures/fib.c | 12 + src/test/app/wasm_fixtures/fixtures.cpp | 2199 +---------------- src/test/app/wasm_fixtures/fixtures.h | 36 +- .../app/wasm_fixtures/float_tests/Cargo.lock | 15 + .../app/wasm_fixtures/float_tests/Cargo.toml | 21 + .../app/wasm_fixtures/float_tests/src/lib.rs | 460 ++++ src/test/app/wasm_fixtures/ledgerSqn.c | 27 + src/test/app/wasm_fixtures/sha512Pure.c | 145 ++ src/test/app/wasm_fixtures/sp1/Cargo.lock | 1384 +++++++++++ src/test/app/wasm_fixtures/sp1/Cargo.toml | 16 + src/test/app/wasm_fixtures/sp1/src/lib.rs | 37 + .../app/wasm_fixtures/zk_proof/Cargo.lock | 106 + .../app/wasm_fixtures/zk_proof/Cargo.toml | 19 + .../app/wasm_fixtures/zk_proof/src/lib.rs | 254 ++ src/xrpld/app/wasm/detail/WamrVM.cpp | 2 +- src/xrpld/app/wasm/detail/WasmVM.cpp | 1 - 33 files changed, 4942 insertions(+), 2357 deletions(-) create mode 100644 src/test/app/wasm_fixtures/.gitignore create mode 100644 src/test/app/wasm_fixtures/all_host_functions/Cargo.lock create mode 100644 src/test/app/wasm_fixtures/all_host_functions/Cargo.toml create mode 100644 src/test/app/wasm_fixtures/all_host_functions/src/lib.rs create mode 100644 src/test/app/wasm_fixtures/all_keylets/Cargo.lock create mode 100644 src/test/app/wasm_fixtures/all_keylets/Cargo.toml create mode 100644 src/test/app/wasm_fixtures/all_keylets/src/lib.rs create mode 100644 src/test/app/wasm_fixtures/b58.c create mode 100644 src/test/app/wasm_fixtures/codecov_tests/Cargo.lock create mode 100644 src/test/app/wasm_fixtures/codecov_tests/Cargo.toml create mode 100644 src/test/app/wasm_fixtures/codecov_tests/src/host_bindings_loose.rs create mode 100644 src/test/app/wasm_fixtures/codecov_tests/src/lib.rs create mode 100644 src/test/app/wasm_fixtures/copyFixtures.py create mode 100644 src/test/app/wasm_fixtures/disableFloat.wat create mode 100644 src/test/app/wasm_fixtures/fib.c create mode 100644 src/test/app/wasm_fixtures/float_tests/Cargo.lock create mode 100644 src/test/app/wasm_fixtures/float_tests/Cargo.toml create mode 100644 src/test/app/wasm_fixtures/float_tests/src/lib.rs create mode 100644 src/test/app/wasm_fixtures/ledgerSqn.c create mode 100644 src/test/app/wasm_fixtures/sha512Pure.c create mode 100644 src/test/app/wasm_fixtures/sp1/Cargo.lock create mode 100644 src/test/app/wasm_fixtures/sp1/Cargo.toml create mode 100644 src/test/app/wasm_fixtures/sp1/src/lib.rs create mode 100644 src/test/app/wasm_fixtures/zk_proof/Cargo.lock create mode 100644 src/test/app/wasm_fixtures/zk_proof/Cargo.toml create mode 100644 src/test/app/wasm_fixtures/zk_proof/src/lib.rs diff --git a/.clang-format b/.clang-format index 660a60c4a1..883549168b 100644 --- a/.clang-format +++ b/.clang-format @@ -95,3 +95,6 @@ Standard: Cpp11 TabWidth: 8 UseTab: Never QualifierAlignment: Right +--- +Language: Json +IndentWidth: 2 diff --git a/src/test/app/Escrow_test.cpp b/src/test/app/Escrow_test.cpp index c07f3edd61..c74b98e8c7 100644 --- a/src/test/app/Escrow_test.cpp +++ b/src/test/app/Escrow_test.cpp @@ -1708,7 +1708,7 @@ struct Escrow_test : public beast::unit_test::suite // Tests whether the ledger index is >= 5 // getLedgerSqn() >= 5} - static auto wasmHex = ledgerSqnHex; + static auto wasmHex = ledgerSqnWasmHex; { // featureSmartEscrow disabled @@ -1884,7 +1884,7 @@ struct Escrow_test : public beast::unit_test::suite // Tests whether the ledger index is >= 5 // getLedgerSqn() >= 5} - static auto wasmHex = ledgerSqnHex; + static auto wasmHex = ledgerSqnWasmHex; { // featureSmartEscrow disabled @@ -1921,37 +1921,6 @@ struct Escrow_test : public beast::unit_test::suite ter(temBAD_LIMIT)); } - { - uint32_t const allowance = 5'664; - Env env(*this, features); - env.fund(XRP(5000), alice, carol); - auto const seq = env.seq(alice); - XRPAmount const createFee = env.current()->fees().base + 1000; - - // Escrow with FinishFunction + Condition - auto escrowCreate = escrow::create(alice, carol, XRP(1000)); - env(escrowCreate, - escrow::finish_function(reqNonexistentField), - escrow::condition(escrow::cb1), - escrow::cancel_time(env.now() + 100s), - fee(createFee)); - env.close(); - env.close(); - - // Rejected as wasm code request nonexistent memo field - XRPAmount const txnFees = env.current()->fees().base * 34 + 1000; - env(escrow::finish(alice, alice, seq), - escrow::condition(escrow::cb1), - escrow::fulfillment(escrow::fb1), - escrow::comp_allowance(allowance), - fee(txnFees), - ter(tecWASM_REJECTED)); - - auto const txMeta = env.meta(); - if (BEAST_EXPECT(txMeta->isFieldPresent(sfGasUsed))) - BEAST_EXPECT(txMeta->getFieldU32(sfGasUsed) == allowance); - } - Env env(*this, features); // Run past the flag ledger so that a Fee change vote occurs and @@ -2036,7 +2005,7 @@ struct Escrow_test : public beast::unit_test::suite // Tests whether the ledger index is >= 5 // getLedgerSqn() >= 5} - auto const& wasmHex = ledgerSqnHex; + auto const& wasmHex = ledgerSqnWasmHex; std::uint32_t const allowance = 71; { @@ -2288,7 +2257,7 @@ struct Escrow_test : public beast::unit_test::suite using namespace std::chrono; // TODO: create wasm module for all host functions - static auto wasmHex = allHostFunctionsHex; + static auto wasmHex = allHostFunctionsWasmHex; Account const alice{"alice"}; Account const carol{"carol"}; @@ -2356,7 +2325,7 @@ struct Escrow_test : public beast::unit_test::suite using namespace std::chrono; // TODO: create wasm module for all host functions - static auto wasmHex = keyletHostFunctions; + static auto wasmHex = allKeyletsWasmHex; Account const alice{"alice"}; Account const carol{"carol"}; diff --git a/src/test/app/Wasm_test.cpp b/src/test/app/Wasm_test.cpp index 42e3951869..46c116637a 100644 --- a/src/test/app/Wasm_test.cpp +++ b/src/test/app/Wasm_test.cpp @@ -57,13 +57,17 @@ struct Wasm_test : public beast::unit_test::suite { testcase("Wasm fibo"); - auto const ws = boost::algorithm::unhex(fib32Hex); + auto const ws = boost::algorithm::unhex(fibWasmHex); Bytes const wasm(ws.begin(), ws.end()); auto& engine = WasmEngine::instance(); auto const re = engine.run(wasm, "fib", wasmParams(10)); - BEAST_EXPECT(re.has_value() && (re->result == 55) && (re->cost == 755)); + if (BEAST_EXPECT(re.has_value())) + { + BEAST_EXPECTS(re->result == 55, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 755, std::to_string(re->cost)); + } } void @@ -71,22 +75,25 @@ struct Wasm_test : public beast::unit_test::suite { testcase("Wasm sha"); - auto const ws = boost::algorithm::unhex(sha512PureHex); + auto const ws = boost::algorithm::unhex(sha512PureWasmHex); Bytes const wasm(ws.begin(), ws.end()); auto& engine = WasmEngine::instance(); auto const re = - engine.run(wasm, "sha512_process", wasmParams(sha512PureHex)); + engine.run(wasm, "sha512_process", wasmParams(sha512PureWasmHex)); - BEAST_EXPECT( - re.has_value() && (re->result == 34432) && (re->cost == 157'452)); + if (BEAST_EXPECT(re.has_value())) + { + BEAST_EXPECTS(re->result == 34'432, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 157'452, std::to_string(re->cost)); + } } void testWasmB58() { testcase("Wasm base58"); - auto const ws = boost::algorithm::unhex(b58Hex); + auto const ws = boost::algorithm::unhex(b58WasmHex); Bytes const wasm(ws.begin(), ws.end()); auto& engine = WasmEngine::instance(); @@ -95,38 +102,51 @@ struct Wasm_test : public beast::unit_test::suite auto const minsz = std::min( static_cast(512), - static_cast(b58Hex.size())); - auto const s = std::string_view(b58Hex.c_str(), minsz); + static_cast(b58WasmHex.size())); + auto const s = std::string_view(b58WasmHex.c_str(), minsz); + auto const re = engine.run(wasm, "b58enco", wasmParams(outb, s)); - BEAST_EXPECT(re.has_value() && re->result && (re->cost == 3'066'129)); + if (BEAST_EXPECT(re.has_value())) + { + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 3'066'129, std::to_string(re->cost)); + } } void testWasmSP1Verifier() { testcase("Wasm sp1 zkproof verifier"); - auto const ws = boost::algorithm::unhex(sp1_wasm); + auto const ws = boost::algorithm::unhex(sp1WasmHex); Bytes const wasm(ws.begin(), ws.end()); auto& engine = WasmEngine::instance(); auto const re = engine.run(wasm, "sp1_groth16_verifier"); - BEAST_EXPECT( - re.has_value() && re->result && (re->cost == 4'191'711'969ll)); + if (BEAST_EXPECT(re.has_value())) + { + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS( + re->cost == 4'191'711'969ll, std::to_string(re->cost)); + } } void testWasmBG16Verifier() { testcase("Wasm BG16 zkproof verifier"); - auto const ws = boost::algorithm::unhex(zkProofHex); + auto const ws = boost::algorithm::unhex(zkProofWasmHex); Bytes const wasm(ws.begin(), ws.end()); auto& engine = WasmEngine::instance(); auto const re = engine.run(wasm, "bellman_groth16_test"); - BEAST_EXPECT(re.has_value() && re->result && (re->cost == 332'205'984)); + if (BEAST_EXPECT(re.has_value())) + { + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 332'205'984, std::to_string(re->cost)); + } } void @@ -134,7 +154,7 @@ struct Wasm_test : public beast::unit_test::suite { testcase("Wasm get ledger sequence"); - auto wasmStr = boost::algorithm::unhex(ledgerSqnHex); + auto wasmStr = boost::algorithm::unhex(ledgerSqnWasmHex); Bytes wasm(wasmStr.begin(), wasmStr.end()); using namespace test::jtx; @@ -157,7 +177,10 @@ struct Wasm_test : public beast::unit_test::suite // code takes 11 gas + 1 getLedgerSqn call if (BEAST_EXPECT(re.has_value())) - BEAST_EXPECT(!re->result && (re->cost == 44)); + { + BEAST_EXPECTS(!re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 44, std::to_string(re->cost)); + } env.close(); env.close(); @@ -170,72 +193,10 @@ struct Wasm_test : public beast::unit_test::suite // code takes 22 gas + 2 getLedgerSqn calls if (BEAST_EXPECT(re.has_value())) - BEAST_EXPECT(re->result && (re->cost == 88)); - } - - void - testWasmCheckJson() - { - testcase("Wasm check json"); - - using namespace test::jtx; - Env env{*this}; - - auto const wasmStr = boost::algorithm::unhex(checkJsonHex); - Bytes const wasm(wasmStr.begin(), wasmStr.end()); - std::string const funcName("check_accountID"); { - std::string str = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"; - Bytes data(str.begin(), str.end()); - auto re = runEscrowWasm( - wasm, funcName, wasmParams(data), nullptr, -1, env.journal); - if (BEAST_EXPECT(re.has_value())) - BEAST_EXPECT(re.value().result && (re->cost == 838)); + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 88, std::to_string(re->cost)); } - { - std::string str = "rHb9CJAWyB4rj91VRWn96DkukG4bwdty00"; - Bytes data(str.begin(), str.end()); - auto re = runEscrowWasm( - wasm, funcName, wasmParams(data), nullptr, -1, env.journal); - if (BEAST_EXPECT(re.has_value())) - BEAST_EXPECT(!re.value().result && (re->cost == 822)); - } - } - - void - testWasmCompareJson() - { - testcase("Wasm compare json"); - - using namespace test::jtx; - Env env{*this}; - - auto wasmStr = boost::algorithm::unhex(compareJsonHex); - std::vector wasm(wasmStr.begin(), wasmStr.end()); - std::string funcName("compare_accountID"); - - std::vector const tx_data(tx_js.begin(), tx_js.end()); - std::vector const lo_data(lo_js.begin(), lo_js.end()); - auto re = runEscrowWasm( - wasm, - funcName, - wasmParams(tx_data, lo_data), - nullptr, - -1, - env.journal); - if (BEAST_EXPECT(re.has_value())) - BEAST_EXPECT(re.value().result && (re->cost == 42'212)); - - std::vector const lo_data2(lo_js2.begin(), lo_js2.end()); - re = runEscrowWasm( - wasm, - funcName, - wasmParams(tx_data, lo_data2), - nullptr, - -1, - env.journal); - if (BEAST_EXPECT(re.has_value())) - BEAST_EXPECT(!re.value().result && (re->cost == 41'496)); } void @@ -281,7 +242,11 @@ struct Wasm_test : public beast::unit_test::suite // if (res) printf("invokeAdd get the result: %d\n", res.value()); - BEAST_EXPECT(re.has_value() && re->result == 6912 && (re->cost == 2)); + if (BEAST_EXPECT(re.has_value())) + { + BEAST_EXPECTS(re->result == 6'912, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 2, std::to_string(re->cost)); + } } void @@ -346,7 +311,7 @@ struct Wasm_test : public beast::unit_test::suite testcase("escrow wasm devnet test"); std::string const wasmStr = - boost::algorithm::unhex(allHostFunctionsHex); + boost::algorithm::unhex(allHostFunctionsWasmHex); std::vector wasm(wasmStr.begin(), wasmStr.end()); using namespace test::jtx; @@ -357,7 +322,8 @@ struct Wasm_test : public beast::unit_test::suite runEscrowWasm(wasm, ESCROW_FUNCTION_NAME, {}, &nfs, 100'000); if (BEAST_EXPECT(re.has_value())) { - BEAST_EXPECT(re->result && (re->cost == 41'132)); + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 41'132, std::to_string(re->cost)); } } @@ -375,11 +341,11 @@ struct Wasm_test : public beast::unit_test::suite }; BadTestHostFunctions nfs(env); auto re = - runEscrowWasm(wasm, ESCROW_FUNCTION_NAME, {}, &nfs, 100000); + runEscrowWasm(wasm, ESCROW_FUNCTION_NAME, {}, &nfs, 100'000); if (BEAST_EXPECT(re.has_value())) { - BEAST_EXPECT(re->result == -201); - BEAST_EXPECT(re->cost == 5831); + BEAST_EXPECTS(re->result == -201, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 5'831, std::to_string(re->cost)); } } @@ -400,8 +366,8 @@ struct Wasm_test : public beast::unit_test::suite runEscrowWasm(wasm, ESCROW_FUNCTION_NAME, {}, &nfs, 100'000); if (BEAST_EXPECT(re.has_value())) { - BEAST_EXPECT(re->result == -201); - BEAST_EXPECT(re->cost == 5831); + BEAST_EXPECTS(re->result == -201, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 5'831, std::to_string(re->cost)); } } @@ -412,7 +378,7 @@ struct Wasm_test : public beast::unit_test::suite TestHostFunctionsSink nfs(env); std::string funcName("recursive"); - auto re = runEscrowWasm(wasm, funcName, {}, &nfs, 1000'000'000); + auto re = runEscrowWasm(wasm, funcName, {}, &nfs, 1'000'000'000); BEAST_EXPECT(!re && re.error()); // std::cout << "bad case (deep recursion) result " << re.error() // << std::endl; @@ -438,7 +404,7 @@ struct Wasm_test : public beast::unit_test::suite } { - auto wasmStr = boost::algorithm::unhex(ledgerSqnHex); + auto wasmStr = boost::algorithm::unhex(ledgerSqnWasmHex); Bytes wasm(wasmStr.begin(), wasmStr.end()); TestLedgerDataProvider ledgerDataProvider(&env); @@ -471,7 +437,7 @@ struct Wasm_test : public beast::unit_test::suite Env env(*this); { - std::string const wasmHex = allHostFunctionsHex; + std::string const wasmHex = allHostFunctionsWasmHex; std::string const wasmStr = boost::algorithm::unhex(wasmHex); std::vector const wasm(wasmStr.begin(), wasmStr.end()); @@ -493,7 +459,8 @@ struct Wasm_test : public beast::unit_test::suite if (BEAST_EXPECT(re.has_value())) { - BEAST_EXPECT(re->result && (re->cost == 872)); + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 872, std::to_string(re->cost)); } env.close(); @@ -506,7 +473,7 @@ struct Wasm_test : public beast::unit_test::suite env.close(); { - std::string const wasmHex = allHostFunctionsHex; + std::string const wasmHex = allHostFunctionsWasmHex; std::string const wasmStr = boost::algorithm::unhex(wasmHex); std::vector const wasm(wasmStr.begin(), wasmStr.end()); @@ -526,7 +493,8 @@ struct Wasm_test : public beast::unit_test::suite if (BEAST_EXPECT(re.has_value())) { - BEAST_EXPECT(re->result && (re->cost == 41'132)); + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 41'132, std::to_string(re->cost)); } env.close(); @@ -544,13 +512,17 @@ struct Wasm_test : public beast::unit_test::suite Env env(*this); { - std::string const wasmHex = floatHex; + std::string const wasmHex = floatTestsWasmHex; std::string const wasmStr = boost::algorithm::unhex(wasmHex); std::vector const wasm(wasmStr.begin(), wasmStr.end()); TestHostFunctions hf(env, 0); auto re = runEscrowWasm(wasm, funcName, {}, &hf, 100'000); - BEAST_EXPECT(re && re->result && (re->cost == 91'412)); + if (BEAST_EXPECT(re.has_value())) + { + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 91'412, std::to_string(re->cost)); + } env.close(); } @@ -561,7 +533,11 @@ struct Wasm_test : public beast::unit_test::suite TestHostFunctions hf(env, 0); auto re = runEscrowWasm(wasm, funcName, {}, &hf, 100'000); - BEAST_EXPECT(re && re->result && (re->cost == 6'533)); + if (BEAST_EXPECT(re.has_value())) + { + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 6'533, std::to_string(re->cost)); + } env.close(); } } @@ -677,7 +653,7 @@ struct Wasm_test : public beast::unit_test::suite // beast::severities::kTrace}; Env env{*this}; - auto const wasmStr = boost::algorithm::unhex(codecovWasm); + auto const wasmStr = boost::algorithm::unhex(codecovTestsWasmHex); Bytes const wasm(wasmStr.begin(), wasmStr.end()); std::string const funcName("finish"); TestHostFunctions hfs(env, 0); @@ -686,7 +662,10 @@ struct Wasm_test : public beast::unit_test::suite runEscrowWasm(wasm, funcName, {}, &hfs, 1'000'000, env.journal); if (BEAST_EXPECT(re.has_value())) - BEAST_EXPECT(re->result); + { + BEAST_EXPECTS(re->result, std::to_string(re->result)); + BEAST_EXPECTS(re->cost == 100'784, std::to_string(re->cost)); + } } void @@ -706,7 +685,10 @@ struct Wasm_test : public beast::unit_test::suite // f32 set constant, opcode disabled exception auto const re = runEscrowWasm(wasm, funcName, {}, &hfs, 1'000'000, env.journal); - BEAST_EXPECT(!re && re.error() == tecFAILED_PROCESSING); + if (BEAST_EXPECT(!re.has_value())) + { + BEAST_EXPECT(re.error() == tecFAILED_PROCESSING); + } } { @@ -714,7 +696,10 @@ struct Wasm_test : public beast::unit_test::suite wasm[0x117] = 0x92; auto const re = runEscrowWasm(wasm, funcName, {}, &hfs, 1'000'000, env.journal); - BEAST_EXPECT(!re && re.error() == tecFAILED_PROCESSING); + if (BEAST_EXPECT(!re.has_value())) + { + BEAST_EXPECT(re.error() == tecFAILED_PROCESSING); + } } } @@ -726,8 +711,6 @@ struct Wasm_test : public beast::unit_test::suite testGetDataHelperFunctions(); testWasmLib(); testBadWasm(); - testWasmCheckJson(); - testWasmCompareJson(); testWasmLedgerSqn(); testWasmFib(); diff --git a/src/test/app/wasm_fixtures/.gitignore b/src/test/app/wasm_fixtures/.gitignore new file mode 100644 index 0000000000..08b2e8a256 --- /dev/null +++ b/src/test/app/wasm_fixtures/.gitignore @@ -0,0 +1,3 @@ +**/target +**/debug +*.wasm diff --git a/src/test/app/wasm_fixtures/all_host_functions/Cargo.lock b/src/test/app/wasm_fixtures/all_host_functions/Cargo.lock new file mode 100644 index 0000000000..13931f0229 --- /dev/null +++ b/src/test/app/wasm_fixtures/all_host_functions/Cargo.lock @@ -0,0 +1,15 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "all_host_functions" +version = "0.1.0" +dependencies = [ + "xrpl-std", +] + +[[package]] +name = "xrpl-std" +version = "0.0.1" +source = "git+https://github.com/ripple/craft.git?branch=main#94fb247e0c21b9e7fecb91ce71ef7f74ef4a7931" diff --git a/src/test/app/wasm_fixtures/all_host_functions/Cargo.toml b/src/test/app/wasm_fixtures/all_host_functions/Cargo.toml new file mode 100644 index 0000000000..4c3455b3ca --- /dev/null +++ b/src/test/app/wasm_fixtures/all_host_functions/Cargo.toml @@ -0,0 +1,21 @@ +[package] +name = "all_host_functions" +version = "0.1.0" +edition = "2024" + +# This empty workspace definition keeps this project independent of the parent workspace +[workspace] + +[lib] +crate-type = ["cdylib"] + +[dependencies] +xrpl-std = { git = "https://github.com/ripple/craft.git", branch = "main", package = "xrpl-std" } + +[profile.dev] +panic = "abort" + +[profile.release] +panic = "abort" +opt-level = "z" +lto = true diff --git a/src/test/app/wasm_fixtures/all_host_functions/src/lib.rs b/src/test/app/wasm_fixtures/all_host_functions/src/lib.rs new file mode 100644 index 0000000000..b685de59da --- /dev/null +++ b/src/test/app/wasm_fixtures/all_host_functions/src/lib.rs @@ -0,0 +1,828 @@ +#![cfg_attr(target_arch = "wasm32", no_std)] + +#[cfg(not(target_arch = "wasm32"))] +extern crate std; + +// +// Host Functions Test +// Tests 26 host functions (across 7 categories) +// +// With craft you can run this test with: +// craft test --project host_functions_test --test-case host_functions_test +// +// Amount Format Update: +// - XRP amounts now return as 8-byte serialized rippled objects +// - IOU and MPT amounts return in variable-length serialized format +// - Format details: https://xrpl.org/docs/references/protocol/binary-format#amount-fields +// +// Error Code Ranges: +// -100 to -199: Ledger Header Functions (3 functions) +// -200 to -299: Transaction Data Functions (5 functions) +// -300 to -399: Current Ledger Object Functions (4 functions) +// -400 to -499: Any Ledger Object Functions (5 functions) +// -500 to -599: Keylet Generation Functions (4 functions) +// -600 to -699: Utility Functions (4 functions) +// -700 to -799: Data Update Functions (1 function) +// + +use xrpl_std::core::current_tx::escrow_finish::EscrowFinish; +use xrpl_std::core::current_tx::traits::TransactionCommonFields; +use xrpl_std::host::trace::{DataRepr, trace_data, trace_num}; +use xrpl_std::host::*; +use xrpl_std::sfield; + +#[unsafe(no_mangle)] +pub extern "C" fn finish() -> i32 { + let _ = trace_data("=== HOST FUNCTIONS TEST ===", &[], DataRepr::AsHex); + let _ = trace_data("Testing 26 host functions", &[], DataRepr::AsHex); + + // Category 1: Ledger Header Data Functions (3 functions) + // Error range: -100 to -199 + match test_ledger_header_functions() { + 0 => (), + err => return err, + } + + // Category 2: Transaction Data Functions (5 functions) + // Error range: -200 to -299 + match test_transaction_data_functions() { + 0 => (), + err => return err, + } + + // Category 3: Current Ledger Object Functions (4 functions) + // Error range: -300 to -399 + match test_current_ledger_object_functions() { + 0 => (), + err => return err, + } + + // Category 4: Any Ledger Object Functions (5 functions) + // Error range: -400 to -499 + match test_any_ledger_object_functions() { + 0 => (), + err => return err, + } + + // Category 5: Keylet Generation Functions (4 functions) + // Error range: -500 to -599 + match test_keylet_generation_functions() { + 0 => (), + err => return err, + } + + // Category 6: Utility Functions (4 functions) + // Error range: -600 to -699 + match test_utility_functions() { + 0 => (), + err => return err, + } + + // Category 7: Data Update Functions (1 function) + // Error range: -700 to -799 + match test_data_update_functions() { + 0 => (), + err => return err, + } + + let _ = trace_data( + "SUCCESS: All host function tests passed!", + &[], + DataRepr::AsHex, + ); + 1 // Success return code for WASM finish function +} + +/// Test Category 1: Ledger Header Data Functions (3 functions) +/// - get_ledger_sqn() - Get ledger sequence number +/// - get_parent_ledger_time() - Get parent ledger timestamp +/// - get_parent_ledger_hash() - Get parent ledger hash +fn test_ledger_header_functions() -> i32 { + let _ = trace_data( + "--- Category 1: Ledger Header Functions ---", + &[], + DataRepr::AsHex, + ); + + // Test 1.1: get_ledger_sqn() - should return current ledger sequence number + let mut ledger_sqn_buffer = [0u8; 8]; + let sqn_result = + unsafe { get_ledger_sqn(ledger_sqn_buffer.as_mut_ptr(), ledger_sqn_buffer.len()) }; + + if sqn_result <= 0 { + let _ = trace_num("ERROR: get_ledger_sqn failed:", sqn_result as i64); + return -101; // Ledger sequence number test failed + } + let _ = trace_num("Ledger sequence number bytes:", sqn_result as i64); + let _ = trace_data( + "Ledger sqn data:", + &ledger_sqn_buffer[..sqn_result as usize], + DataRepr::AsHex, + ); + + // Test 1.2: get_parent_ledger_time() - should return parent ledger timestamp + let mut time_buffer = [0u8; 8]; + let time_result = + unsafe { get_parent_ledger_time(time_buffer.as_mut_ptr(), time_buffer.len()) }; + + if time_result <= 0 { + let _ = trace_num("ERROR: get_parent_ledger_time failed:", time_result as i64); + return -102; // Parent ledger time test failed + } + let _ = trace_num("Parent ledger time bytes:", time_result as i64); + let _ = trace_data( + "Parent time data:", + &time_buffer[..time_result as usize], + DataRepr::AsHex, + ); + + // Test 1.3: get_parent_ledger_hash() - should return parent ledger hash (32 bytes) + let mut hash_buffer = [0u8; 32]; + let hash_result = + unsafe { get_parent_ledger_hash(hash_buffer.as_mut_ptr(), hash_buffer.len()) }; + + if hash_result != 32 { + let _ = trace_num( + "ERROR: get_parent_ledger_hash wrong length:", + hash_result as i64, + ); + return -103; // Parent ledger hash test failed - should be exactly 32 bytes + } + let _ = trace_data("Parent ledger hash:", &hash_buffer, DataRepr::AsHex); + + let _ = trace_data("SUCCESS: Ledger header functions", &[], DataRepr::AsHex); + 0 +} + +/// Test Category 2: Transaction Data Functions (5 functions) +/// Tests all functions for accessing current transaction data +fn test_transaction_data_functions() -> i32 { + let _ = trace_data( + "--- Category 2: Transaction Data Functions ---", + &[], + DataRepr::AsHex, + ); + + // Test 2.1: get_tx_field() - Basic transaction field access + // Test with Account field (required, 20 bytes) + let mut account_buffer = [0u8; 20]; + let account_len = unsafe { + get_tx_field( + sfield::Account, + account_buffer.as_mut_ptr(), + account_buffer.len(), + ) + }; + + if account_len != 20 { + let _ = trace_num( + "ERROR: get_tx_field(Account) wrong length:", + account_len as i64, + ); + return -201; // Basic transaction field test failed + } + let _ = trace_data("Transaction Account:", &account_buffer, DataRepr::AsHex); + + // Test with Fee field (XRP amount - 8 bytes in new serialized format) + // New format: XRP amounts are always 8 bytes (positive: value | cPositive flag, negative: just value) + let mut fee_buffer = [0u8; 8]; + let fee_len = unsafe { get_tx_field(sfield::Fee, fee_buffer.as_mut_ptr(), fee_buffer.len()) }; + + if fee_len != 8 { + let _ = trace_num( + "ERROR: get_tx_field(Fee) wrong length (expected 8 bytes for XRP):", + fee_len as i64, + ); + return -202; // Fee field test failed - XRP amounts should be exactly 8 bytes + } + let _ = trace_num("Transaction Fee length:", fee_len as i64); + let _ = trace_data( + "Transaction Fee (serialized XRP amount):", + &fee_buffer, + DataRepr::AsHex, + ); + + // Test with Sequence field (required, 4 bytes uint32) + let mut seq_buffer = [0u8; 4]; + let seq_len = + unsafe { get_tx_field(sfield::Sequence, seq_buffer.as_mut_ptr(), seq_buffer.len()) }; + + if seq_len != 4 { + let _ = trace_num( + "ERROR: get_tx_field(Sequence) wrong length:", + seq_len as i64, + ); + return -203; // Sequence field test failed + } + let _ = trace_data("Transaction Sequence:", &seq_buffer, DataRepr::AsHex); + + // NOTE: get_tx_field2() through get_tx_field6() have been deprecated. + // Use get_tx_field() with appropriate parameters for all transaction field access. + + // Test 2.2: get_tx_nested_field() - Nested field access with locator + let locator = [0x01, 0x00]; // Simple locator for first element + let mut nested_buffer = [0u8; 32]; + let nested_result = unsafe { + get_tx_nested_field( + locator.as_ptr(), + locator.len(), + nested_buffer.as_mut_ptr(), + nested_buffer.len(), + ) + }; + + if nested_result < 0 { + let _ = trace_num( + "INFO: get_tx_nested_field not applicable:", + nested_result as i64, + ); + // Expected - locator may not match transaction structure + } else { + let _ = trace_num("Nested field length:", nested_result as i64); + let _ = trace_data( + "Nested field:", + &nested_buffer[..nested_result as usize], + DataRepr::AsHex, + ); + } + + // Test 2.3: get_tx_array_len() - Get array length + let signers_len = unsafe { get_tx_array_len(sfield::Signers) }; + let _ = trace_num("Signers array length:", signers_len as i64); + + let memos_len = unsafe { get_tx_array_len(sfield::Memos) }; + let _ = trace_num("Memos array length:", memos_len as i64); + + // Test 2.4: get_tx_nested_array_len() - Get nested array length with locator + let nested_array_len = unsafe { get_tx_nested_array_len(locator.as_ptr(), locator.len()) }; + + if nested_array_len < 0 { + let _ = trace_num( + "INFO: get_tx_nested_array_len not applicable:", + nested_array_len as i64, + ); + } else { + let _ = trace_num("Nested array length:", nested_array_len as i64); + } + + let _ = trace_data("SUCCESS: Transaction data functions", &[], DataRepr::AsHex); + 0 +} + +/// Test Category 3: Current Ledger Object Functions (4 functions) +/// Tests functions that access the current ledger object being processed +fn test_current_ledger_object_functions() -> i32 { + let _ = trace_data( + "--- Category 3: Current Ledger Object Functions ---", + &[], + DataRepr::AsHex, + ); + + // Test 3.1: get_current_ledger_obj_field() - Access field from current ledger object + // Test with Balance field (XRP amount - 8 bytes in new serialized format) + let mut balance_buffer = [0u8; 8]; + let balance_result = unsafe { + get_current_ledger_obj_field( + sfield::Balance, + balance_buffer.as_mut_ptr(), + balance_buffer.len(), + ) + }; + + if balance_result <= 0 { + let _ = trace_num( + "INFO: get_current_ledger_obj_field(Balance) failed (may be expected):", + balance_result as i64, + ); + // This might fail if current ledger object doesn't have balance field + } else if balance_result == 8 { + let _ = trace_num( + "Current object balance length (XRP amount):", + balance_result as i64, + ); + let _ = trace_data( + "Current object balance (serialized XRP amount):", + &balance_buffer, + DataRepr::AsHex, + ); + } else { + let _ = trace_num( + "Current object balance length (non-XRP amount):", + balance_result as i64, + ); + let _ = trace_data( + "Current object balance:", + &balance_buffer[..balance_result as usize], + DataRepr::AsHex, + ); + } + + // Test with Account field + let mut current_account_buffer = [0u8; 20]; + let current_account_result = unsafe { + get_current_ledger_obj_field( + sfield::Account, + current_account_buffer.as_mut_ptr(), + current_account_buffer.len(), + ) + }; + + if current_account_result <= 0 { + let _ = trace_num( + "INFO: get_current_ledger_obj_field(Account) failed:", + current_account_result as i64, + ); + } else { + let _ = trace_data( + "Current ledger object account:", + ¤t_account_buffer[..current_account_result as usize], + DataRepr::AsHex, + ); + } + + // Test 3.2: get_current_ledger_obj_nested_field() - Nested field access + let locator = [0x01, 0x00]; // Simple locator + let mut current_nested_buffer = [0u8; 32]; + let current_nested_result = unsafe { + get_current_ledger_obj_nested_field( + locator.as_ptr(), + locator.len(), + current_nested_buffer.as_mut_ptr(), + current_nested_buffer.len(), + ) + }; + + if current_nested_result < 0 { + let _ = trace_num( + "INFO: get_current_ledger_obj_nested_field not applicable:", + current_nested_result as i64, + ); + } else { + let _ = trace_num("Current nested field length:", current_nested_result as i64); + let _ = trace_data( + "Current nested field:", + ¤t_nested_buffer[..current_nested_result as usize], + DataRepr::AsHex, + ); + } + + // Test 3.3: get_current_ledger_obj_array_len() - Array length in current object + let current_array_len = unsafe { get_current_ledger_obj_array_len(sfield::Signers) }; + let _ = trace_num( + "Current object Signers array length:", + current_array_len as i64, + ); + + // Test 3.4: get_current_ledger_obj_nested_array_len() - Nested array length + let current_nested_array_len = + unsafe { get_current_ledger_obj_nested_array_len(locator.as_ptr(), locator.len()) }; + + if current_nested_array_len < 0 { + let _ = trace_num( + "INFO: get_current_ledger_obj_nested_array_len not applicable:", + current_nested_array_len as i64, + ); + } else { + let _ = trace_num( + "Current nested array length:", + current_nested_array_len as i64, + ); + } + + let _ = trace_data( + "SUCCESS: Current ledger object functions", + &[], + DataRepr::AsHex, + ); + 0 +} + +/// Test Category 4: Any Ledger Object Functions (5 functions) +/// Tests functions that work with cached ledger objects +fn test_any_ledger_object_functions() -> i32 { + let _ = trace_data( + "--- Category 4: Any Ledger Object Functions ---", + &[], + DataRepr::AsHex, + ); + + // First we need to cache a ledger object to test the other functions + // Get the account from transaction and generate its keylet + let escrow_finish = EscrowFinish; + let account_id = escrow_finish.get_account().unwrap(); + + // Test 4.1: cache_ledger_obj() - Cache a ledger object + let mut keylet_buffer = [0u8; 32]; + let keylet_result = unsafe { + account_keylet( + account_id.0.as_ptr(), + account_id.0.len(), + keylet_buffer.as_mut_ptr(), + keylet_buffer.len(), + ) + }; + + if keylet_result != 32 { + let _ = trace_num( + "ERROR: account_keylet failed for caching test:", + keylet_result as i64, + ); + return -401; // Keylet generation failed for caching test + } + + let cache_result = + unsafe { cache_ledger_obj(keylet_buffer.as_ptr(), keylet_result as usize, 0) }; + + if cache_result <= 0 { + let _ = trace_num( + "INFO: cache_ledger_obj failed (expected with test fixtures):", + cache_result as i64, + ); + // Test fixtures may not contain the account object - this is expected + // We'll test the interface but expect failures + + // Test 4.2-4.5 with invalid slot (should fail gracefully) + let mut test_buffer = [0u8; 32]; + + // Test get_ledger_obj_field with invalid slot + let field_result = unsafe { + get_ledger_obj_field( + 1, + sfield::Balance, + test_buffer.as_mut_ptr(), + test_buffer.len(), + ) + }; + if field_result < 0 { + let _ = trace_num( + "INFO: get_ledger_obj_field failed as expected (no cached object):", + field_result as i64, + ); + } + + // Test get_ledger_obj_nested_field with invalid slot + let locator = [0x01, 0x00]; + let nested_result = unsafe { + get_ledger_obj_nested_field( + 1, + locator.as_ptr(), + locator.len(), + test_buffer.as_mut_ptr(), + test_buffer.len(), + ) + }; + if nested_result < 0 { + let _ = trace_num( + "INFO: get_ledger_obj_nested_field failed as expected:", + nested_result as i64, + ); + } + + // Test get_ledger_obj_array_len with invalid slot + let array_result = unsafe { get_ledger_obj_array_len(1, sfield::Signers) }; + if array_result < 0 { + let _ = trace_num( + "INFO: get_ledger_obj_array_len failed as expected:", + array_result as i64, + ); + } + + // Test get_ledger_obj_nested_array_len with invalid slot + let nested_array_result = + unsafe { get_ledger_obj_nested_array_len(1, locator.as_ptr(), locator.len()) }; + if nested_array_result < 0 { + let _ = trace_num( + "INFO: get_ledger_obj_nested_array_len failed as expected:", + nested_array_result as i64, + ); + } + + let _ = trace_data( + "SUCCESS: Any ledger object functions (interface tested)", + &[], + DataRepr::AsHex, + ); + return 0; + } + + // If we successfully cached an object, test the access functions + let slot = cache_result; + let _ = trace_num("Successfully cached object in slot:", slot as i64); + + // Test 4.2: get_ledger_obj_field() - Access field from cached object + let mut cached_balance_buffer = [0u8; 8]; + let cached_balance_result = unsafe { + get_ledger_obj_field( + slot, + sfield::Balance, + cached_balance_buffer.as_mut_ptr(), + cached_balance_buffer.len(), + ) + }; + + if cached_balance_result <= 0 { + let _ = trace_num( + "INFO: get_ledger_obj_field(Balance) failed:", + cached_balance_result as i64, + ); + } else if cached_balance_result == 8 { + let _ = trace_num( + "Cached object balance length (XRP amount):", + cached_balance_result as i64, + ); + let _ = trace_data( + "Cached object balance (serialized XRP amount):", + &cached_balance_buffer, + DataRepr::AsHex, + ); + } else { + let _ = trace_num( + "Cached object balance length (non-XRP amount):", + cached_balance_result as i64, + ); + let _ = trace_data( + "Cached object balance:", + &cached_balance_buffer[..cached_balance_result as usize], + DataRepr::AsHex, + ); + } + + // Test 4.3: get_ledger_obj_nested_field() - Nested field from cached object + let locator = [0x01, 0x00]; + let mut cached_nested_buffer = [0u8; 32]; + let cached_nested_result = unsafe { + get_ledger_obj_nested_field( + slot, + locator.as_ptr(), + locator.len(), + cached_nested_buffer.as_mut_ptr(), + cached_nested_buffer.len(), + ) + }; + + if cached_nested_result < 0 { + let _ = trace_num( + "INFO: get_ledger_obj_nested_field not applicable:", + cached_nested_result as i64, + ); + } else { + let _ = trace_num("Cached nested field length:", cached_nested_result as i64); + let _ = trace_data( + "Cached nested field:", + &cached_nested_buffer[..cached_nested_result as usize], + DataRepr::AsHex, + ); + } + + // Test 4.4: get_ledger_obj_array_len() - Array length from cached object + let cached_array_len = unsafe { get_ledger_obj_array_len(slot, sfield::Signers) }; + let _ = trace_num( + "Cached object Signers array length:", + cached_array_len as i64, + ); + + // Test 4.5: get_ledger_obj_nested_array_len() - Nested array length from cached object + let cached_nested_array_len = + unsafe { get_ledger_obj_nested_array_len(slot, locator.as_ptr(), locator.len()) }; + + if cached_nested_array_len < 0 { + let _ = trace_num( + "INFO: get_ledger_obj_nested_array_len not applicable:", + cached_nested_array_len as i64, + ); + } else { + let _ = trace_num( + "Cached nested array length:", + cached_nested_array_len as i64, + ); + } + + let _ = trace_data("SUCCESS: Any ledger object functions", &[], DataRepr::AsHex); + 0 +} + +/// Test Category 5: Keylet Generation Functions (4 functions) +/// Tests keylet generation functions for different ledger entry types +fn test_keylet_generation_functions() -> i32 { + let _ = trace_data( + "--- Category 5: Keylet Generation Functions ---", + &[], + DataRepr::AsHex, + ); + + let escrow_finish = EscrowFinish; + let account_id = escrow_finish.get_account().unwrap(); + + // Test 5.1: account_keylet() - Generate keylet for account + let mut account_keylet_buffer = [0u8; 32]; + let account_keylet_result = unsafe { + account_keylet( + account_id.0.as_ptr(), + account_id.0.len(), + account_keylet_buffer.as_mut_ptr(), + account_keylet_buffer.len(), + ) + }; + + if account_keylet_result != 32 { + let _ = trace_num( + "ERROR: account_keylet failed:", + account_keylet_result as i64, + ); + return -501; // Account keylet generation failed + } + let _ = trace_data("Account keylet:", &account_keylet_buffer, DataRepr::AsHex); + + // Test 5.2: credential_keylet() - Generate keylet for credential + let mut credential_keylet_buffer = [0u8; 32]; + let credential_keylet_result = unsafe { + credential_keylet( + account_id.0.as_ptr(), // Subject + account_id.0.len(), + account_id.0.as_ptr(), // Issuer - same account for test + account_id.0.len(), + b"TestType".as_ptr(), // Credential type + 9usize, // Length of "TestType" + credential_keylet_buffer.as_mut_ptr(), + credential_keylet_buffer.len(), + ) + }; + + if credential_keylet_result <= 0 { + let _ = trace_num( + "INFO: credential_keylet failed (expected - interface issue):", + credential_keylet_result as i64, + ); + // This is expected to fail due to unusual parameter types + } else { + let _ = trace_data( + "Credential keylet:", + &credential_keylet_buffer[..credential_keylet_result as usize], + DataRepr::AsHex, + ); + } + + // Test 5.3: escrow_keylet() - Generate keylet for escrow + let mut escrow_keylet_buffer = [0u8; 32]; + let escrow_keylet_result = unsafe { + escrow_keylet( + account_id.0.as_ptr(), + account_id.0.len(), + 1000, // Sequence number + escrow_keylet_buffer.as_mut_ptr(), + escrow_keylet_buffer.len(), + ) + }; + + if escrow_keylet_result != 32 { + let _ = trace_num("ERROR: escrow_keylet failed:", escrow_keylet_result as i64); + return -503; // Escrow keylet generation failed + } + let _ = trace_data("Escrow keylet:", &escrow_keylet_buffer, DataRepr::AsHex); + + // Test 5.4: oracle_keylet() - Generate keylet for oracle + let mut oracle_keylet_buffer = [0u8; 32]; + let oracle_keylet_result = unsafe { + oracle_keylet( + account_id.0.as_ptr(), + account_id.0.len(), + 42, // Document ID + oracle_keylet_buffer.as_mut_ptr(), + oracle_keylet_buffer.len(), + ) + }; + + if oracle_keylet_result != 32 { + let _ = trace_num("ERROR: oracle_keylet failed:", oracle_keylet_result as i64); + return -504; // Oracle keylet generation failed + } + let _ = trace_data("Oracle keylet:", &oracle_keylet_buffer, DataRepr::AsHex); + + let _ = trace_data("SUCCESS: Keylet generation functions", &[], DataRepr::AsHex); + 0 +} + +/// Test Category 6: Utility Functions (4 functions) +/// Tests utility functions for hashing, NFT access, and tracing +fn test_utility_functions() -> i32 { + let _ = trace_data( + "--- Category 6: Utility Functions ---", + &[], + DataRepr::AsHex, + ); + + // Test 6.1: compute_sha512_half() - SHA512 hash computation (first 32 bytes) + let test_data = b"Hello, XRPL WASM world!"; + let mut hash_output = [0u8; 32]; + let hash_result = unsafe { + compute_sha512_half( + test_data.as_ptr(), + test_data.len(), + hash_output.as_mut_ptr(), + hash_output.len(), + ) + }; + + if hash_result != 32 { + let _ = trace_num("ERROR: compute_sha512_half failed:", hash_result as i64); + return -601; // SHA512 half computation failed + } + let _ = trace_data("Input data:", test_data, DataRepr::AsHex); + let _ = trace_data("SHA512 half hash:", &hash_output, DataRepr::AsHex); + + // Test 6.2: get_nft() - NFT data retrieval + let escrow_finish = EscrowFinish; + let account_id = escrow_finish.get_account().unwrap(); + let nft_id = [0u8; 32]; // Dummy NFT ID for testing + let mut nft_buffer = [0u8; 256]; + let nft_result = unsafe { + get_nft( + account_id.0.as_ptr(), + account_id.0.len(), + nft_id.as_ptr(), + nft_id.len(), + nft_buffer.as_mut_ptr(), + nft_buffer.len(), + ) + }; + + if nft_result <= 0 { + let _ = trace_num( + "INFO: get_nft failed (expected - no such NFT):", + nft_result as i64, + ); + // This is expected - test account likely doesn't own the dummy NFT + } else { + let _ = trace_num("NFT data length:", nft_result as i64); + let _ = trace_data( + "NFT data:", + &nft_buffer[..nft_result as usize], + DataRepr::AsHex, + ); + } + + // Test 6.3: trace() - Debug logging with data + let trace_message = b"Test trace message"; + let trace_data_payload = b"payload"; + let trace_result = unsafe { + trace( + trace_message.as_ptr(), + trace_message.len(), + trace_data_payload.as_ptr(), + trace_data_payload.len(), + 1, // as_hex = true + ) + }; + + if trace_result < 0 { + let _ = trace_num("ERROR: trace() failed:", trace_result as i64); + return -603; // Trace function failed + } + let _ = trace_num("Trace function bytes written:", trace_result as i64); + + // Test 6.4: trace_num() - Debug logging with number + let test_number = 42i64; + let trace_num_result = trace_num("Test number trace", test_number); + + use xrpl_std::host::Result; + match trace_num_result { + Result::Ok(_) => { + let _ = trace_num("Trace_num function succeeded", 0); + } + Result::Err(_) => { + let _ = trace_num("ERROR: trace_num() failed:", -604); + return -604; // Trace number function failed + } + } + + let _ = trace_data("SUCCESS: Utility functions", &[], DataRepr::AsHex); + 0 +} + +/// Test Category 7: Data Update Functions (1 function) +/// Tests the function for modifying the current ledger entry +fn test_data_update_functions() -> i32 { + let _ = trace_data( + "--- Category 7: Data Update Functions ---", + &[], + DataRepr::AsHex, + ); + + // Test 7.1: update_data() - Update current ledger entry data + let update_payload = b"Updated ledger entry data from WASM test"; + + let update_result = unsafe { update_data(update_payload.as_ptr(), update_payload.len()) }; + + if update_result != 0 { + let _ = trace_num("ERROR: update_data failed:", update_result as i64); + return -701; // Data update failed + } + + let _ = trace_data( + "Successfully updated ledger entry with:", + update_payload, + DataRepr::AsHex, + ); + let _ = trace_data("SUCCESS: Data update functions", &[], DataRepr::AsHex); + 0 +} diff --git a/src/test/app/wasm_fixtures/all_keylets/Cargo.lock b/src/test/app/wasm_fixtures/all_keylets/Cargo.lock new file mode 100644 index 0000000000..cc667d4d34 --- /dev/null +++ b/src/test/app/wasm_fixtures/all_keylets/Cargo.lock @@ -0,0 +1,15 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "all_keylets" +version = "0.0.1" +dependencies = [ + "xrpl-std", +] + +[[package]] +name = "xrpl-std" +version = "0.0.1" +source = "git+https://github.com/ripple/craft.git?branch=main#94fb247e0c21b9e7fecb91ce71ef7f74ef4a7931" diff --git a/src/test/app/wasm_fixtures/all_keylets/Cargo.toml b/src/test/app/wasm_fixtures/all_keylets/Cargo.toml new file mode 100644 index 0000000000..e1fd222beb --- /dev/null +++ b/src/test/app/wasm_fixtures/all_keylets/Cargo.toml @@ -0,0 +1,21 @@ +[package] +edition = "2024" +name = "all_keylets" +version = "0.0.1" + +# This empty workspace definition keeps this project independent of the parent workspace +[workspace] + +[lib] +crate-type = ["cdylib"] + +[profile.release] +lto = true +opt-level = 's' +panic = "abort" + +[dependencies] +xrpl-std = { git = "https://github.com/ripple/craft.git", branch = "main", package = "xrpl-std" } + +[profile.dev] +panic = "abort" diff --git a/src/test/app/wasm_fixtures/all_keylets/src/lib.rs b/src/test/app/wasm_fixtures/all_keylets/src/lib.rs new file mode 100644 index 0000000000..167541eae6 --- /dev/null +++ b/src/test/app/wasm_fixtures/all_keylets/src/lib.rs @@ -0,0 +1,156 @@ +#![cfg_attr(target_arch = "wasm32", no_std)] + +#[cfg(not(target_arch = "wasm32"))] +extern crate std; + +use crate::host::{Result, Result::Err, Result::Ok}; +use xrpl_std::core::ledger_objects::current_escrow::get_current_escrow; +use xrpl_std::core::ledger_objects::current_escrow::CurrentEscrow; +use xrpl_std::core::ledger_objects::ledger_object; +use xrpl_std::core::ledger_objects::traits::CurrentEscrowFields; +use xrpl_std::core::types::amount::currency_code::CurrencyCode; +use xrpl_std::core::types::keylets; +use xrpl_std::host; +use xrpl_std::host::trace::{trace, trace_data, trace_num, DataRepr}; +use xrpl_std::sfield; + +#[unsafe(no_mangle)] +pub fn object_exists( + keylet_result: Result, + keylet_type: &str, + field: i32, +) -> Result { + match keylet_result { + Ok(keylet) => { + let _ = trace_data(keylet_type, &keylet, DataRepr::AsHex); + + let slot = unsafe { host::cache_ledger_obj(keylet.as_ptr(), keylet.len(), 0) }; + if slot <= 0 { + let _ = trace_num("Error: ", slot.into()); + return Err(host::Error::NoFreeSlots); + } + if field == 0 { + let new_field = sfield::PreviousTxnID; + let _ = trace_num("Getting field: ", new_field.into()); + match ledger_object::get_hash_256_field(slot, new_field) { + Ok(data) => { + let _ = trace_data("Field data: ", &data.0, DataRepr::AsHex); + } + Err(result_code) => { + let _ = trace_num("Error getting field: ", result_code.into()); + return Err(result_code); + } + } + } else { + let _ = trace_num("Getting field: ", field.into()); + match ledger_object::get_account_id_field(slot, field) { + Ok(data) => { + let _ = trace_data("Field data: ", &data.0, DataRepr::AsHex); + } + Err(result_code) => { + let _ = trace_num("Error getting field: ", result_code.into()); + return Err(result_code); + } + } + } + + Ok(true) + } + Err(error) => { + let _ = trace_num("Error getting keylet: ", error.into()); + Err(error) + } + } +} + +#[unsafe(no_mangle)] +pub extern "C" fn finish() -> i32 { + let _ = trace("$$$$$ STARTING WASM EXECUTION $$$$$"); + + let escrow: CurrentEscrow = get_current_escrow(); + + let account = escrow.get_account().unwrap_or_panic(); + let _ = trace_data(" Account:", &account.0, DataRepr::AsHex); + + let destination = escrow.get_destination().unwrap_or_panic(); + let _ = trace_data(" Destination:", &destination.0, DataRepr::AsHex); + + macro_rules! check_object_exists { + ($keylet:expr, $type:expr, $field:expr) => { + match object_exists($keylet, $type, $field) { + Ok(exists) => { + if exists { + let _ = trace(concat!( + $type, + " object exists, proceeding with escrow finish." + )); + } else { + let _ = trace(concat!( + $type, + " object does not exist, aborting escrow finish." + )); + return 0; + } + } + Err(error) => return error.code(), + } + }; + } + + let account_keylet = keylets::account_keylet(&account); + check_object_exists!(account_keylet, "Account", sfield::Account); + + let mut seq = 5; + let currency_code: &[u8; 3] = b"USD"; + let currency: CurrencyCode = CurrencyCode::from(*currency_code); + let line_keylet = keylets::line_keylet(&account, &destination, ¤cy); + check_object_exists!(line_keylet, "Trustline", sfield::Generic); + seq += 1; + + let check_keylet = keylets::check_keylet(&account, seq); + check_object_exists!(check_keylet, "Check", sfield::Account); + seq += 1; + + let cred_type: &[u8] = b"termsandconditions"; + let credential_keylet = keylets::credential_keylet(&account, &account, cred_type); + check_object_exists!(credential_keylet, "Credential", sfield::Subject); + seq += 1; + + let delegate_keylet = keylets::delegate_keylet(&account, &destination); + check_object_exists!(delegate_keylet, "Delegate", sfield::Account); + seq += 1; + + let deposit_preauth_keylet = keylets::deposit_preauth_keylet(&account, &destination); + check_object_exists!(deposit_preauth_keylet, "DepositPreauth", sfield::Account); + seq += 1; + + let did_keylet = keylets::did_keylet(&account); + check_object_exists!(did_keylet, "DID", sfield::Account); + seq += 1; + + let escrow_keylet = keylets::escrow_keylet(&account, seq); + check_object_exists!(escrow_keylet, "Escrow", sfield::Account); + seq += 1; + + let nft_offer_keylet = keylets::nft_offer_keylet(&destination, 4); + check_object_exists!(nft_offer_keylet, "NFTokenOffer", sfield::Owner); + + let offer_keylet = keylets::offer_keylet(&account, seq); + check_object_exists!(offer_keylet, "Offer", sfield::Account); + seq += 1; + + let paychan_keylet = keylets::paychan_keylet(&account, &destination, seq); + check_object_exists!(paychan_keylet, "PayChannel", sfield::Account); + seq += 1; + + let signers_keylet = keylets::signers_keylet(&account); + check_object_exists!(signers_keylet, "SignerList", sfield::Generic); + seq += 1; + + seq += 1; // ticket sequence number is one greater + let ticket_keylet = keylets::ticket_keylet(&account, seq); + check_object_exists!(ticket_keylet, "Ticket", sfield::Account); + // seq += 1; + + 1 // All keylets exist, finish the escrow. +} diff --git a/src/test/app/wasm_fixtures/b58.c b/src/test/app/wasm_fixtures/b58.c new file mode 100644 index 0000000000..00b6178ec0 --- /dev/null +++ b/src/test/app/wasm_fixtures/b58.c @@ -0,0 +1,73 @@ +#include + +static char const b58digits_ordered[] = + "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; + +uint8_t e_data[32 * 1024]; + +void* +allocate(int sz) +{ + static int idx = 0; + if (idx >= 32) + return 0; + if (sz > 1024) + return 0; + return &e_data[idx++ << 10]; +} + +void +deallocate(void* p) +{ +} + +extern int32_t +b58enco(char* b58, int32_t b58sz, void const* data, int32_t binsz) +{ + uint8_t const* bin = data; + int32_t carry; + int32_t i, j, high, zcount = 0; + int32_t size; + + while (zcount < binsz && !bin[zcount]) + ++zcount; + + size = (binsz - zcount) * 138 / 100 + 1; + uint8_t* buf = allocate(size); + if (!buf) + return 0; + // memset(buf, 0, size); + for (i = 0; i < size; ++i) + buf[i] = 0; + + for (i = zcount, high = size - 1; i < binsz; ++i, high = j) + { + for (carry = bin[i], j = size - 1; (j > high) || carry; --j) + { + carry += 256 * buf[j]; + buf[j] = carry % 58; + carry /= 58; + if (!j) + break; + } + } + + for (j = 0; j < size && !buf[j]; ++j) + ; + + if (b58sz <= zcount + size - j) + return 0; + + if (zcount) + { + // memset(b58, '1', zcount); + for (i = 0; i < zcount; ++i) + b58[i] = '1'; + } + + for (i = zcount; j < size; ++i, ++j) + b58[i] = b58digits_ordered[buf[j]]; + b58[i] = '\0'; + + return i + 1; +} diff --git a/src/test/app/wasm_fixtures/codecov_tests/Cargo.lock b/src/test/app/wasm_fixtures/codecov_tests/Cargo.lock new file mode 100644 index 0000000000..00b548911b --- /dev/null +++ b/src/test/app/wasm_fixtures/codecov_tests/Cargo.lock @@ -0,0 +1,15 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "codecov_tests" +version = "0.0.1" +dependencies = [ + "xrpl-std", +] + +[[package]] +name = "xrpl-std" +version = "0.0.1" +source = "git+https://github.com/ripple/craft.git?branch=main#94fb247e0c21b9e7fecb91ce71ef7f74ef4a7931" diff --git a/src/test/app/wasm_fixtures/codecov_tests/Cargo.toml b/src/test/app/wasm_fixtures/codecov_tests/Cargo.toml new file mode 100644 index 0000000000..e379fe9790 --- /dev/null +++ b/src/test/app/wasm_fixtures/codecov_tests/Cargo.toml @@ -0,0 +1,19 @@ +[package] +edition = "2024" +name = "codecov_tests" +version = "0.0.1" + +# This empty workspace definition keeps this project independent of the parent workspace +[workspace] + +[lib] +crate-type = ["cdylib"] + +[profile.release] +lto = true +opt-level = 's' +panic = "abort" + +[dependencies] +xrpl-std = { git = "https://github.com/ripple/craft.git", branch = "main", package = "xrpl-std" } + diff --git a/src/test/app/wasm_fixtures/codecov_tests/src/host_bindings_loose.rs b/src/test/app/wasm_fixtures/codecov_tests/src/host_bindings_loose.rs new file mode 100644 index 0000000000..0e8a1ecee0 --- /dev/null +++ b/src/test/app/wasm_fixtures/codecov_tests/src/host_bindings_loose.rs @@ -0,0 +1,47 @@ +//TODO add docs after discussing the interface +//Note that Craft currently does not honor the rounding modes +#[allow(unused)] +pub const FLOAT_ROUNDING_MODES_TO_NEAREST: i32 = 0; +#[allow(unused)] +pub const FLOAT_ROUNDING_MODES_TOWARDS_ZERO: i32 = 1; +#[allow(unused)] +pub const FLOAT_ROUNDING_MODES_DOWNWARD: i32 = 2; +#[allow(unused)] +pub const FLOAT_ROUNDING_MODES_UPWARD: i32 = 3; + +// pub enum RippledRoundingModes{ +// ToNearest = 0, +// TowardsZero = 1, +// DOWNWARD = 2, +// UPWARD = 3 +// } + +#[allow(unused)] +#[link(wasm_import_module = "host_lib")] +unsafe extern "C" { + pub fn get_ledger_sqn(out_buff_ptr: i32, out_buff_len: i32) -> i32; + + pub fn cache_ledger_obj(keylet_ptr: i32, keylet_len: i32, cache_num: i32) -> i32; + + pub fn get_tx_nested_array_len(locator_ptr: i32, locator_len: i32) -> i32; + + pub fn account_keylet( + account_ptr: i32, + account_len: i32, + out_buff_ptr: *mut u8, + out_buff_len: usize, + ) -> i32; + + pub fn line_keylet( + account1_ptr: *const u8, + account1_len: usize, + account2_ptr: *const u8, + account2_len: usize, + currency_ptr: i32, + currency_len: i32, + out_buff_ptr: *mut u8, + out_buff_len: usize, + ) -> i32; + + pub fn trace_num(msg_read_ptr: i32, msg_read_len: i32, number: i64) -> i32; +} diff --git a/src/test/app/wasm_fixtures/codecov_tests/src/lib.rs b/src/test/app/wasm_fixtures/codecov_tests/src/lib.rs new file mode 100644 index 0000000000..1323068b39 --- /dev/null +++ b/src/test/app/wasm_fixtures/codecov_tests/src/lib.rs @@ -0,0 +1,953 @@ +#![cfg_attr(target_arch = "wasm32", no_std)] + +#[cfg(not(target_arch = "wasm32"))] +extern crate std; + +use core::panic; +use xrpl_std::core::current_tx::escrow_finish::{EscrowFinish, get_current_escrow_finish}; +use xrpl_std::core::current_tx::traits::TransactionCommonFields; +use xrpl_std::core::error_codes; +use xrpl_std::core::locator::Locator; +use xrpl_std::core::types::keylets; +use xrpl_std::host; +use xrpl_std::host::trace::{trace, trace_num as trace_number}; +use xrpl_std::sfield; + +mod host_bindings_loose; +include!("host_bindings_loose.rs"); + +fn check_result(result: i32, expected: i32, test_name: &'static str) { + match result { + code if code == expected => { + let _ = trace_number(test_name, code.into()); + } + code if code >= 0 => { + let _ = trace(test_name); + let _ = trace_number("TEST FAILED", code.into()); + panic!("Unexpected success code: {}", code); + } + code => { + let _ = trace_number("TEST FAILED", code.into()); + panic!("Error code: {}", code); + } + } +} + +fn with_buffer(mut f: F) -> R +where + F: FnMut(*mut u8, usize) -> R, +{ + let mut buf = [0u8; N]; + f(buf.as_mut_ptr(), buf.len()) +} + +#[unsafe(no_mangle)] +pub extern "C" fn finish() -> i32 { + let _ = trace("$$$$$ STARTING WASM EXECUTION $$$$$"); + + // ######################################## + // Step #1: Test all host function happy paths + // Note: not testing all the keylet functions, + // that's in a separate test file. + // ######################################## + with_buffer::<4, _, _>(|ptr, len| { + check_result( + unsafe { host::get_ledger_sqn(ptr, len) }, + 4, + "get_ledger_sqn", + ) + }); + with_buffer::<4, _, _>(|ptr, len| { + check_result( + unsafe { host::get_parent_ledger_time(ptr, len) }, + 4, + "get_parent_ledger_time", + ); + }); + with_buffer::<32, _, _>(|ptr, len| { + check_result( + unsafe { host::get_parent_ledger_hash(ptr, len) }, + 32, + "get_parent_ledger_hash", + ); + }); + with_buffer::<32, _, _>(|ptr, len| { + check_result( + unsafe { host::get_ledger_account_hash(ptr, len) }, + 32, + "get_ledger_account_hash", + ); + }); + with_buffer::<32, _, _>(|ptr, len| { + check_result( + unsafe { host::get_ledger_tx_hash(ptr, len) }, + 32, + "get_ledger_tx_hash", + ); + }); + check_result(unsafe { host::get_base_fee() }, 10, "get_base_fee"); + let amendment_name: &[u8] = b"test_amendment"; + let amendment_id: [u8; 32] = [1; 32]; + check_result( + unsafe { host::amendment_enabled(amendment_name.as_ptr(), amendment_name.len()) }, + 1, + "amendment_enabled", + ); + check_result( + unsafe { host::amendment_enabled(amendment_id.as_ptr(), amendment_id.len()) }, + 1, + "amendment_enabled", + ); + let tx: EscrowFinish = get_current_escrow_finish(); + let account = tx.get_account().unwrap_or_panic(); // get_tx_field under the hood + let keylet = keylets::account_keylet(&account).unwrap_or_panic(); // account_keylet under the hood + check_result( + unsafe { host::cache_ledger_obj(keylet.as_ptr(), keylet.len(), 0) }, + 1, + "cache_ledger_obj", + ); + with_buffer::<20, _, _>(|ptr, len| { + check_result( + unsafe { host::get_current_ledger_obj_field(sfield::Account, ptr, len) }, + 20, + "get_current_ledger_obj_field", + ); + }); + with_buffer::<20, _, _>(|ptr, len| { + check_result( + unsafe { host::get_ledger_obj_field(1, sfield::Account, ptr, len) }, + 20, + "get_ledger_obj_field", + ); + }); + let mut locator = Locator::new(); + locator.pack(sfield::Account); + with_buffer::<20, _, _>(|ptr, len| { + check_result( + unsafe { host::get_tx_nested_field(locator.as_ptr(), locator.len(), ptr, len) }, + 20, + "get_tx_nested_field", + ); + }); + with_buffer::<20, _, _>(|ptr, len| { + check_result( + unsafe { + host::get_current_ledger_obj_nested_field(locator.as_ptr(), locator.len(), ptr, len) + }, + 20, + "get_current_ledger_obj_nested_field", + ); + }); + with_buffer::<20, _, _>(|ptr, len| { + check_result( + unsafe { + host::get_ledger_obj_nested_field(1, locator.as_ptr(), locator.len(), ptr, len) + }, + 20, + "get_ledger_obj_nested_field", + ); + }); + check_result( + unsafe { host::get_tx_array_len(sfield::Memos) }, + 32, + "get_tx_array_len", + ); + check_result( + unsafe { host::get_current_ledger_obj_array_len(sfield::Memos) }, + 32, + "get_current_ledger_obj_array_len", + ); + check_result( + unsafe { host::get_ledger_obj_array_len(1, sfield::Memos) }, + 32, + "get_ledger_obj_array_len", + ); + check_result( + unsafe { host::get_tx_nested_array_len(locator.as_ptr(), locator.len()) }, + 32, + "get_tx_nested_array_len", + ); + check_result( + unsafe { host::get_current_ledger_obj_nested_array_len(locator.as_ptr(), locator.len()) }, + 32, + "get_current_ledger_obj_nested_array_len", + ); + check_result( + unsafe { host::get_ledger_obj_nested_array_len(1, locator.as_ptr(), locator.len()) }, + 32, + "get_ledger_obj_nested_array_len", + ); + check_result( + unsafe { host::update_data(account.0.as_ptr(), account.0.len()) }, + 0, + "update_data", + ); + with_buffer::<32, _, _>(|ptr, len| { + check_result( + unsafe { host::compute_sha512_half(locator.as_ptr(), locator.len(), ptr, len) }, + 32, + "compute_sha512_half", + ); + }); + let message: &[u8] = b"test message"; + let pubkey: &[u8] = b"test pubkey"; //tx.get_public_key().unwrap_or_panic(); + let signature: &[u8] = b"test signature"; + check_result( + unsafe { + host::check_sig( + message.as_ptr(), + message.len(), + pubkey.as_ptr(), + pubkey.len(), + signature.as_ptr(), + signature.len(), + ) + }, + 1, + "check_sig", + ); + + let nft_id: [u8; 32] = amendment_id; + with_buffer::<18, _, _>(|ptr, len| { + check_result( + unsafe { + host::get_nft( + account.0.as_ptr(), + account.0.len(), + nft_id.as_ptr(), + nft_id.len(), + ptr, + len, + ) + }, + 18, + "get_nft", + ) + }); + with_buffer::<20, _, _>(|ptr, len| { + check_result( + unsafe { host::get_nft_issuer(nft_id.as_ptr(), nft_id.len(), ptr, len) }, + 20, + "get_nft_issuer", + ) + }); + with_buffer::<4, _, _>(|ptr, len| { + check_result( + unsafe { host::get_nft_taxon(nft_id.as_ptr(), nft_id.len(), ptr, len) }, + 4, + "get_nft_taxon", + ) + }); + check_result( + unsafe { host::get_nft_flags(nft_id.as_ptr(), nft_id.len()) }, + 8, + "get_nft_flags", + ); + check_result( + unsafe { host::get_nft_transfer_fee(nft_id.as_ptr(), nft_id.len()) }, + 10, + "get_nft_transfer_fee", + ); + with_buffer::<4, _, _>(|ptr, len| { + check_result( + unsafe { host::get_nft_serial(nft_id.as_ptr(), nft_id.len(), ptr, len) }, + 4, + "get_nft_serial", + ) + }); + + // ######################################## + // Step #2: Test set_data edge cases + // ######################################## + check_result( + unsafe { host_bindings_loose::get_ledger_sqn(-1, 4) }, + error_codes::INVALID_PARAMS, + "get_ledger_sqn_neg_ptr", + ); + with_buffer::<4, _, _>(|ptr, _len| { + check_result( + unsafe { host_bindings_loose::get_ledger_sqn(ptr as i32, -1) }, + error_codes::INVALID_PARAMS, + "get_ledger_sqn_neg_len", + ) + }); + with_buffer::<3, _, _>(|ptr, len| { + check_result( + unsafe { host_bindings_loose::get_ledger_sqn(ptr as i32, len as i32) }, + error_codes::BUFFER_TOO_SMALL, + "get_ledger_sqn_buf_too_small", + ) + }); + with_buffer::<4, _, _>(|ptr, _len| { + check_result( + unsafe { host_bindings_loose::get_ledger_sqn(ptr as i32, 1_000_000_000) }, + error_codes::POINTER_OUT_OF_BOUNDS, + "get_ledger_sqn_len_too_long", + ) + }); + + // ######################################## + // Step #3: Test getData[Type] edge cases + // ######################################## + + // SField + check_result( + unsafe { host::get_tx_array_len(2) }, // not a valid SField value + error_codes::INVALID_FIELD, + "get_tx_array_len_invalid_sfield", + ); + + // Slice + check_result( + unsafe { host_bindings_loose::get_tx_nested_array_len(-1, locator.len() as i32) }, + error_codes::INVALID_PARAMS, + "get_tx_nested_array_len_neg_ptr", + ); + check_result( + unsafe { host_bindings_loose::get_tx_nested_array_len(locator.as_ptr() as i32, -1) }, + error_codes::INVALID_PARAMS, + "get_tx_nested_array_len_neg_len", + ); + let long_len = 4 * 1024 + 1; + check_result( + unsafe { + host_bindings_loose::get_tx_nested_array_len(locator.as_ptr() as i32, long_len as i32) + }, + error_codes::DATA_FIELD_TOO_LARGE, + "get_tx_nested_array_len_too_long", + ); + check_result( + unsafe { + host_bindings_loose::get_tx_nested_array_len( + locator.as_ptr() as i32 + 1_000_000_000, + locator.len() as i32, + ) + }, + error_codes::POINTER_OUT_OF_BOUNDS, + "get_tx_nested_array_len_ptr_oob", + ); + + // uint256 + check_result( + unsafe { + host_bindings_loose::cache_ledger_obj( + locator.as_ptr() as i32 + 1_000_000_000, + locator.len() as i32, + 1, + ) + }, + error_codes::POINTER_OUT_OF_BOUNDS, + "cache_ledger_obj_ptr_oob", + ); + check_result( + unsafe { + host_bindings_loose::cache_ledger_obj(locator.as_ptr() as i32, locator.len() as i32, 1) + }, + error_codes::INVALID_PARAMS, + "cache_ledger_obj_wrong_len", + ); + + // AccountID + with_buffer::<32, _, _>(|ptr, len| { + check_result( + unsafe { + host_bindings_loose::account_keylet( + locator.as_ptr() as i32 + 1_000_000_000, + locator.len() as i32, + ptr, + len, + ) + }, + error_codes::POINTER_OUT_OF_BOUNDS, + "account_keylet_len_too_long", + ) + }); + with_buffer::<32, _, _>(|ptr, len| { + check_result( + unsafe { + host_bindings_loose::account_keylet( + locator.as_ptr() as i32, + locator.len() as i32, + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "account_keylet_wrong_len", + ) + }); + + // Currency + with_buffer::<32, _, _>(|ptr, len| { + check_result( + unsafe { + host_bindings_loose::line_keylet( + account.0.as_ptr(), + account.0.len(), + account.0.as_ptr(), + account.0.len(), + locator.as_ptr() as i32 + 1_000_000_000, + locator.len() as i32, + ptr, + len, + ) + }, + error_codes::POINTER_OUT_OF_BOUNDS, + "line_keylet_len_too_long_currency", + ) + }); + with_buffer::<32, _, _>(|ptr, len| { + check_result( + unsafe { + host_bindings_loose::line_keylet( + account.0.as_ptr(), + account.0.len(), + account.0.as_ptr(), + account.0.len(), + locator.as_ptr() as i32, + locator.len() as i32, + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "line_keylet_wrong_len_currency", + ) + }); + + // string + check_result( + unsafe { + host_bindings_loose::trace_num( + locator.as_ptr() as i32 + 1_000_000_000, + locator.len() as i32, + 42, + ) + }, + error_codes::POINTER_OUT_OF_BOUNDS, + "trace_num_wrong_len_str", + ); + + // ######################################## + // Step #4: Test other host function edge cases + // ######################################## + + // invalid SFields + + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::get_tx_field(2, ptr, len) }, + error_codes::INVALID_FIELD, + "get_tx_field_invalid_sfield", + ); + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::get_current_ledger_obj_field(2, ptr, len) }, + error_codes::INVALID_FIELD, + "get_current_ledger_obj_field_invalid_sfield", + ); + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::get_ledger_obj_field(1, 2, ptr, len) }, + error_codes::INVALID_FIELD, + "get_ledger_obj_field_invalid_sfield", + ); + }); + check_result( + unsafe { host::get_tx_array_len(2) }, + error_codes::INVALID_FIELD, + "get_tx_array_len_invalid_sfield", + ); + check_result( + unsafe { host::get_current_ledger_obj_array_len(2) }, + error_codes::INVALID_FIELD, + "get_current_ledger_obj_array_len_invalid_sfield", + ); + check_result( + unsafe { host::get_ledger_obj_array_len(1, 2) }, + error_codes::INVALID_FIELD, + "get_ledger_obj_array_len_invalid_sfield", + ); + + // invalid Slice + + check_result( + unsafe { host::amendment_enabled(amendment_name.as_ptr(), long_len) }, + error_codes::DATA_FIELD_TOO_LARGE, + "amendment_enabled", + ); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::get_tx_nested_field(locator.as_ptr(), long_len, ptr, len) }, + error_codes::DATA_FIELD_TOO_LARGE, + "get_tx_nested_field_too_big_slice", + ); + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::get_current_ledger_obj_nested_field(locator.as_ptr(), long_len, ptr, len) + }, + error_codes::DATA_FIELD_TOO_LARGE, + "get_current_ledger_obj_nested_field_too_big_slice", + ); + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::get_ledger_obj_nested_field(1, locator.as_ptr(), long_len, ptr, len) }, + error_codes::DATA_FIELD_TOO_LARGE, + "get_ledger_obj_nested_field_too_big_slice", + ); + }); + check_result( + unsafe { host::get_tx_nested_array_len(locator.as_ptr(), long_len) }, + error_codes::DATA_FIELD_TOO_LARGE, + "get_tx_nested_array_len_too_big_slice", + ); + check_result( + unsafe { host::get_current_ledger_obj_nested_array_len(locator.as_ptr(), long_len) }, + error_codes::DATA_FIELD_TOO_LARGE, + "get_current_ledger_obj_nested_array_len_too_big_slice", + ); + check_result( + unsafe { host::get_ledger_obj_nested_array_len(1, locator.as_ptr(), long_len) }, + error_codes::DATA_FIELD_TOO_LARGE, + "get_ledger_obj_nested_array_len_too_big_slice", + ); + check_result( + unsafe { host::update_data(locator.as_ptr(), long_len) }, + error_codes::DATA_FIELD_TOO_LARGE, + "update_data_too_big_slice", + ); + check_result( + unsafe { + host::check_sig( + message.as_ptr(), + long_len, + pubkey.as_ptr(), + pubkey.len(), + signature.as_ptr(), + signature.len(), + ) + }, + error_codes::DATA_FIELD_TOO_LARGE, + "check_sig", + ); + check_result( + unsafe { + host::check_sig( + message.as_ptr(), + message.len(), + pubkey.as_ptr(), + long_len, + signature.as_ptr(), + signature.len(), + ) + }, + error_codes::DATA_FIELD_TOO_LARGE, + "check_sig", + ); + check_result( + unsafe { + host::check_sig( + message.as_ptr(), + message.len(), + pubkey.as_ptr(), + pubkey.len(), + signature.as_ptr(), + long_len, + ) + }, + error_codes::DATA_FIELD_TOO_LARGE, + "check_sig", + ); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::compute_sha512_half(locator.as_ptr(), long_len, ptr, len) }, + error_codes::DATA_FIELD_TOO_LARGE, + "compute_sha512_half_too_big_slice", + ); + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::credential_keylet( + account.0.as_ptr(), + account.0.len(), + account.0.as_ptr(), + account.0.len(), + locator.as_ptr(), + long_len, + ptr, + len, + ) + }, + error_codes::DATA_FIELD_TOO_LARGE, + "credential_keylet_too_big_slice", + ) + }); + check_result( + unsafe { + host::trace( + locator.as_ptr(), + locator.len(), + locator.as_ptr().wrapping_add(1_000_000_000), + locator.len(), + 0, + ) + }, + error_codes::POINTER_OUT_OF_BOUNDS, + "trace_oob_slice", + ); + + // invalid UInt256 + + check_result( + unsafe { host::cache_ledger_obj(locator.as_ptr(), locator.len(), 0) }, + error_codes::INVALID_PARAMS, + "cache_ledger_obj_wrong_size_uint256", + ); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::get_nft( + account.0.as_ptr(), + account.0.len(), + locator.as_ptr(), + locator.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "get_nft_wrong_size_uint256", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::get_nft_issuer(locator.as_ptr(), locator.len(), ptr, len) }, + error_codes::INVALID_PARAMS, + "get_nft_issuer_wrong_size_uint256", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::get_nft_taxon(locator.as_ptr(), locator.len(), ptr, len) }, + error_codes::INVALID_PARAMS, + "get_nft_taxon_wrong_size_uint256", + ) + }); + check_result( + unsafe { host::get_nft_flags(locator.as_ptr(), locator.len()) }, + error_codes::INVALID_PARAMS, + "get_nft_flags_wrong_size_uint256", + ); + check_result( + unsafe { host::get_nft_transfer_fee(locator.as_ptr(), locator.len()) }, + error_codes::INVALID_PARAMS, + "get_nft_transfer_fee_wrong_size_uint256", + ); + with_buffer::<4, _, _>(|ptr, len| { + check_result( + unsafe { host::get_nft_serial(locator.as_ptr(), locator.len(), ptr, len) }, + error_codes::INVALID_PARAMS, + "get_nft_serial_wrong_size_uint256", + ) + }); + + // invalid AccountID + + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::account_keylet(locator.as_ptr(), locator.len(), ptr, len) }, + error_codes::INVALID_PARAMS, + "account_keylet_wrong_size_accountid", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::check_keylet(locator.as_ptr(), locator.len(), 1, ptr, len) }, + error_codes::INVALID_PARAMS, + "check_keylet_wrong_size_accountid", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::credential_keylet( + locator.as_ptr(), // invalid AccountID size + locator.len(), + account.0.as_ptr(), + account.0.len(), + locator.as_ptr(), // valid slice size + locator.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "credential_keylet_wrong_size_accountid1", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::credential_keylet( + account.0.as_ptr(), + account.0.len(), + locator.as_ptr(), // invalid AccountID size + locator.len(), + locator.as_ptr(), // valid slice size + locator.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "credential_keylet_wrong_size_accountid2", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::delegate_keylet( + locator.as_ptr(), // invalid AccountID size + locator.len(), + account.0.as_ptr(), + account.0.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "delegate_keylet_wrong_size_accountid1", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::delegate_keylet( + account.0.as_ptr(), + account.0.len(), + locator.as_ptr(), // invalid AccountID size + locator.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "delegate_keylet_wrong_size_accountid2", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::deposit_preauth_keylet( + locator.as_ptr(), // invalid AccountID size + locator.len(), + account.0.as_ptr(), + account.0.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "deposit_preauth_keylet_wrong_size_accountid1", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::deposit_preauth_keylet( + account.0.as_ptr(), + account.0.len(), + locator.as_ptr(), // invalid AccountID size + locator.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "deposit_preauth_keylet_wrong_size_accountid2", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::did_keylet(locator.as_ptr(), locator.len(), ptr, len) }, + error_codes::INVALID_PARAMS, + "did_keylet_wrong_size_accountid", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::escrow_keylet(locator.as_ptr(), locator.len(), 1, ptr, len) }, + error_codes::INVALID_PARAMS, + "escrow_keylet_wrong_size_accountid", + ) + }); + let currency: &[u8] = b"USD00000000000000000"; // 20 bytes + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::line_keylet( + locator.as_ptr(), // invalid AccountID size + locator.len(), + account.0.as_ptr(), + account.0.len(), + currency.as_ptr(), + currency.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "line_keylet_wrong_size_accountid1", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::line_keylet( + account.0.as_ptr(), + account.0.len(), + locator.as_ptr(), // invalid AccountID size + locator.len(), + currency.as_ptr(), + currency.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "line_keylet_wrong_size_accountid2", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::nft_offer_keylet(locator.as_ptr(), locator.len(), 1, ptr, len) }, + error_codes::INVALID_PARAMS, + "nft_offer_keylet_wrong_size_accountid", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::offer_keylet(locator.as_ptr(), locator.len(), 1, ptr, len) }, + error_codes::INVALID_PARAMS, + "offer_keylet_wrong_size_accountid", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::oracle_keylet(locator.as_ptr(), locator.len(), 1, ptr, len) }, + error_codes::INVALID_PARAMS, + "oracle_keylet_wrong_size_accountid", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::paychan_keylet( + locator.as_ptr(), // invalid AccountID size + locator.len(), + account.0.as_ptr(), + account.0.len(), + 1, + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "paychan_keylet_wrong_size_accountid1", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::paychan_keylet( + account.0.as_ptr(), + account.0.len(), + locator.as_ptr(), // invalid AccountID size + locator.len(), + 1, + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "paychan_keylet_wrong_size_accountid2", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::signers_keylet(locator.as_ptr(), locator.len(), ptr, len) }, + error_codes::INVALID_PARAMS, + "signers_keylet_wrong_size_accountid", + ) + }); + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { host::ticket_keylet(locator.as_ptr(), locator.len(), 1, ptr, len) }, + error_codes::INVALID_PARAMS, + "ticket_keylet_wrong_size_accountid", + ) + }); + let uint256: &[u8] = b"00000000000000000000000000000001"; + with_buffer::<2, _, _>(|ptr, len| { + check_result( + unsafe { + host::get_nft( + locator.as_ptr(), + locator.len(), + uint256.as_ptr(), + uint256.len(), + ptr, + len, + ) + }, + error_codes::INVALID_PARAMS, + "get_nft_wrong_size_accountid", + ) + }); + + // invalid Currency was already tested above + // invalid string + + check_result( + unsafe { + host::trace( + locator.as_ptr().wrapping_add(1_000_000_000), + locator.len(), + uint256.as_ptr(), + uint256.len(), + 0, + ) + }, + error_codes::POINTER_OUT_OF_BOUNDS, + "get_nft_wrong_size_string", + ); + + // trace too large + + check_result( + unsafe { + host::trace( + locator.as_ptr(), + locator.len(), + locator.as_ptr(), + long_len, + 0, + ) + }, + error_codes::DATA_FIELD_TOO_LARGE, + "trace_too_long", + ); + check_result( + unsafe { host::trace_num(locator.as_ptr(), long_len, 1) }, + error_codes::DATA_FIELD_TOO_LARGE, + "trace_num_too_long", + ); + + 1 // <-- If we get here, finish the escrow. +} diff --git a/src/test/app/wasm_fixtures/copyFixtures.py b/src/test/app/wasm_fixtures/copyFixtures.py new file mode 100644 index 0000000000..1198946eb5 --- /dev/null +++ b/src/test/app/wasm_fixtures/copyFixtures.py @@ -0,0 +1,130 @@ +import os +import sys +import subprocess +import re + +OPT = "-Oz" + + +def update_fixture(project_name, wasm): + fixture_name = ( + re.sub(r"_([a-z])", lambda m: m.group(1).upper(), project_name) + "WasmHex" + ) + print(f"Updating fixture: {fixture_name}") + + cpp_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "fixtures.cpp")) + h_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "fixtures.h")) + with open(cpp_path, "r", encoding="utf8") as f: + cpp_content = f.read() + + pattern = rf'extern std::string const {fixture_name} =[ \n]+"[^;]*;' + if re.search(pattern, cpp_content, flags=re.MULTILINE): + updated_cpp_content = re.sub( + pattern, + f'extern std::string const {fixture_name} = "{wasm}";', + cpp_content, + flags=re.MULTILINE, + ) + else: + with open(h_path, "r", encoding="utf8") as f: + h_content = f.read() + updated_h_content = ( + h_content.rstrip() + f"\n\n extern std::string const {fixture_name};\n" + ) + with open(h_path, "w", encoding="utf8") as f: + f.write(updated_h_content) + updated_cpp_content = ( + cpp_content.rstrip() + + f'\n\nextern std::string const {fixture_name} = "{wasm}";\n' + ) + + with open(cpp_path, "w", encoding="utf8") as f: + f.write(updated_cpp_content) + + +def process_rust(project_name): + project_path = os.path.abspath( + os.path.join(os.path.dirname(__file__), project_name) + ) + wasm_location = f"target/wasm32-unknown-unknown/release/{project_name}.wasm" + build_cmd = ( + f"(cd {project_path} " + f"&& cargo build --target wasm32-unknown-unknown --release " + f"&& wasm-opt {wasm_location} {OPT} -o {wasm_location}" + ")" + ) + try: + result = subprocess.run( + build_cmd, shell=True, check=True, capture_output=True, text=True + ) + print(f"stdout: {result.stdout}") + if result.stderr: + print(f"stderr: {result.stderr}") + print(f"WASM file for {project_name} has been built and optimized.") + except subprocess.CalledProcessError as e: + print(f"exec error: {e}") + sys.exit(1) + + src_path = os.path.abspath( + os.path.join( + os.path.dirname(__file__), + f"{project_name}/target/wasm32-unknown-unknown/release/{project_name}.wasm", + ) + ) + with open(src_path, "rb") as f: + data = f.read() + wasm = data.hex() + update_fixture(project_name, wasm) + + +def process_c(project_name): + project_path = os.path.abspath( + os.path.join(os.path.dirname(__file__), f"{project_name}.c") + ) + wasm_path = os.path.abspath( + os.path.join(os.path.dirname(__file__), f"{project_name}.wasm") + ) + build_cmd = ( + f"$CC --sysroot=$SYSROOT -I$SYSROOT/include/wasm32-wasi " + f"-O3 -ffast-math --target=wasm32 -fno-exceptions -fno-threadsafe-statics -fvisibility=default -Wl,--export-all -Wl,--no-entry -Wl,--allow-undefined -DNDEBUG --no-standard-libraries -fno-builtin-memset " + f"-o {wasm_path} {project_path}" + f"&& wasm-opt {wasm_path} {OPT} -o {wasm_path}" + ) + try: + result = subprocess.run( + build_cmd, shell=True, check=True, capture_output=True, text=True + ) + print(f"stdout: {result.stdout}") + if result.stderr: + print(f"stderr: {result.stderr}") + print( + f"WASM file for {project_name} has been built with WASI support using clang." + ) + except subprocess.CalledProcessError as e: + print(f"exec error: {e}") + sys.exit(1) + + with open(wasm_path, "rb") as f: + data = f.read() + wasm = data.hex() + update_fixture(project_name, wasm) + + +if __name__ == "__main__": + if len(sys.argv) > 2: + print("Usage: python copyFixtures.py []") + sys.exit(1) + if len(sys.argv) == 2: + process_rust(sys.argv[1]) + else: + dirs = [ + d + for d in os.listdir(os.path.dirname(__file__)) + if os.path.isdir(os.path.join(os.path.dirname(__file__), d)) + ] + c_files = [f for f in os.listdir(os.path.dirname(__file__)) if f.endswith(".c")] + for d in dirs: + process_rust(d) + for c in c_files: + process_c(c[:-2]) + print("All fixtures have been processed.") diff --git a/src/test/app/wasm_fixtures/disableFloat.wat b/src/test/app/wasm_fixtures/disableFloat.wat new file mode 100644 index 0000000000..035a849e30 --- /dev/null +++ b/src/test/app/wasm_fixtures/disableFloat.wat @@ -0,0 +1,34 @@ +(module + (type (;0;) (func)) + (type (;1;) (func (result i32))) + (func (;0;) (type 0)) + (func (;1;) (type 1) (result i32) + f32.const -2048 + f32.const 2050 + f32.sub + drop + i32.const 1) + (memory (;0;) 2) + (global (;0;) i32 (i32.const 1024)) + (global (;1;) i32 (i32.const 1024)) + (global (;2;) i32 (i32.const 2048)) + (global (;3;) i32 (i32.const 2048)) + (global (;4;) i32 (i32.const 67584)) + (global (;5;) i32 (i32.const 1024)) + (global (;6;) i32 (i32.const 67584)) + (global (;7;) i32 (i32.const 131072)) + (global (;8;) i32 (i32.const 0)) + (global (;9;) i32 (i32.const 1)) + (export "memory" (memory 0)) + (export "__wasm_call_ctors" (func 0)) + (export "finish" (func 1)) + (export "buf" (global 0)) + (export "__dso_handle" (global 1)) + (export "__data_end" (global 2)) + (export "__stack_low" (global 3)) + (export "__stack_high" (global 4)) + (export "__global_base" (global 5)) + (export "__heap_base" (global 6)) + (export "__heap_end" (global 7)) + (export "__memory_base" (global 8)) + (export "__table_base" (global 9))) diff --git a/src/test/app/wasm_fixtures/fib.c b/src/test/app/wasm_fixtures/fib.c new file mode 100644 index 0000000000..4410923054 --- /dev/null +++ b/src/test/app/wasm_fixtures/fib.c @@ -0,0 +1,12 @@ +// typedef long long mint; +typedef int mint; + +mint +fib(mint n) +{ + if (!n) + return 0; + if (n <= 2) + return 1; + return fib(n - 1) + fib(n - 2); +} diff --git a/src/test/app/wasm_fixtures/fixtures.cpp b/src/test/app/wasm_fixtures/fixtures.cpp index 3424de7006..9e530997a0 100644 --- a/src/test/app/wasm_fixtures/fixtures.cpp +++ b/src/test/app/wasm_fixtures/fixtures.cpp @@ -21,67 +21,14 @@ #include -extern std::string const tx_js = R"({ - "Account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", - "Fee" : "10", - "Flags" : 2147483648, - "OfferSequence" : 2, - "Owner" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", - "Sequence" : 3, - "SigningPubKey" : "0330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020", - "TransactionType" : "EscrowFinish", - "TxnSignature" : "30450221008AD5EE48F7F1047813E79C174FE401D023A4B4A7B99AF826E081DB1DFF7B9C510220133F05B7FD3D7D7F163E8C77EE0A49D02619AB6C77CC3487D0095C9B34033C1C", - "hash" : "74465121372813CBA4C77E31F12E137163F5B2509B16AC1703ECF0DA194B2DD4" - })"; -extern std::string const lo_js = R"({ - "Account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", - "Amount" : "100000", - "CancelAfter" : 790297421, - "Destination" : "rBYn44yhs8cf8G2t79XMUHYQpp2ayhqwcw", - "DestinationNode" : "0", - "FinishAfter" : 790297403, - "FinishFunction" : "0061736D0100000001180460027F7F0060017F017F60027F7F017F60047F7F7F7F00030C0B01010200000000000003000405017001030305030100110619037F01418080C0000B7F0041DD85C0000B7F0041E085C0000B074205066D656D6F7279020008616C6C6F6361746500000F636865636B5F6163636F756E74494400020A5F5F646174615F656E6403010B5F5F686561705F6261736503020908010041010B02060A0AF5360B610002", - "Flags" : 0, - "LedgerEntryType" : "Escrow", - "OwnerNode" : "0", - "PreviousTxnID" : "CF25D1C6B8E637C7DAC61B586F820A16896A3090D9F6FBF9FA00D8B13A265647", - "PreviousTxnLgrSeq" : 4, - "index" : "9BC6631F3EC761CF9BD846D006560E2D57B0A5C91D4570AEB209645B189A702F" - })"; - -extern std::string const lo_js2 = R"({ - "Account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdty00", - "Amount" : "100000", - "CancelAfter" : 790297421, - "Destination" : "rBYn44yhs8cf8G2t79XMUHYQpp2ayhqwcw", - "DestinationNode" : "0", - "FinishAfter" : 790297403, - "FinishFunction" : "0061736D0100000001180460027F7F0060017F017F60027F7F017F60047F7F7F7F00030C0B01010200000000000003000405017001030305030100110619037F01418080C0000B7F0041DD85C0000B7F0041E085C0000B074205066D656D6F7279020008616C6C6F6361746500000F636865636B5F6163636F756E74494400020A5F5F646174615F656E6403010B5F5F686561705F6261736503020908010041010B02060A0AF5360B610002", - "Flags" : 0, - "LedgerEntryType" : "Escrow", - "OwnerNode": "0", - "PreviousTxnID": "CF25D1C6B8E637C7DAC61B586F820A16896A3090D9F6FBF9FA00D8B13A265647", - "PreviousTxnLgrSeq" : 4, - "index" : "9BC6631F3EC761CF9BD846D006560E2D57B0A5C91D4570AEB209645B189A702F" - })"; - -extern std::string const fib32Hex = +extern std::string const fibWasmHex = "0061736d0100000001090260000060017f017f0303020001071b02115f5f" "7761736d5f63616c6c5f63746f727300000366696200010a440202000b3f" "01017f200045044041000f0b2000410348044041010f0b200041026a2100" "0340200041036b100120016a2101200041026b220041044a0d000b200141" "016a0b"; -extern std::string const fib64Hex = - "0061736d0100000001090260000060017e017e0303020001071b02115f5f" - "7761736d5f63616c6c5f63746f727300000366696200010a440202000b3f" - "01017e200050044042000f0b2000420353044042010f0b200042027c2100" - "0340200042037d100120017c2101200042027d22004204550d000b200142" - "017c0b00490f7461726765745f6665617475726573042b0f6d757461626c" - "652d676c6f62616c732b087369676e2d6578742b0f7265666572656e6365" - "2d74797065732b0a6d756c746976616c7565"; - -extern std::string const b58Hex = +extern std::string const b58WasmHex = "0061736d0100000001150460000060017f017f60017f0060047f7f7f7f01" "7f0305040001020305030100020607017f0041d0080b074906066d656d6f" "72790200115f5f7761736d5f63616c6c5f63746f7273000008616c6c6f63" @@ -117,7 +64,7 @@ extern std::string const b58Hex = "2b0f6d757461626c652d676c6f62616c732b087369676e2d6578742b0f72" "65666572656e63652d74797065732b0a6d756c746976616c7565"; -extern std::string const sha512PureHex = +extern std::string const sha512PureWasmHex = "0061736d0100000001130460000060017f017f60017f0060027f7f017f03" "05040001020305030100020607017f0041800d0b075006066d656d6f7279" "0200115f5f7761736d5f63616c6c5f63746f7273000008616c6c6f636174" @@ -175,2097 +122,7 @@ extern std::string const sha512PureHex = "6c6f62616c732b087369676e2d6578742b0f7265666572656e63652d7479" "7065732b0a6d756c746976616c7565"; -extern std::string const checkJsonHex = - "0061736d0100000001180460027f7f0060017f017f60027f7f017f60047f7f7f7f" - "00030c0b01010200000000000003000405017001030305030100110619037f0141" - "8080c0000b7f0041dd85c0000b7f0041e085c0000b074205066d656d6f72790200" - "08616c6c6f6361746500000f636865636b5f6163636f756e74494400020a5f5f64" - "6174615f656e6403010b5f5f686561705f6261736503020908010041010b02060a" - "0af5360b61000240200041004e0440200045044041010f0b418882c0002d00001a" - "200010012200450d0120000f0b230041206b220024002000410036021820004101" - "36020c200041b480c00036020820004204370210200041086a41d080c000100500" - "0b000bee2202087f017e02400240024002400240024002400240200041f4014d04" - "4041ac85c000280200220241102000410b6a41f803712000410b491b2205410376" - "22007622014103710d01200541b485c0002802004d0d0720010d0241b085c00028" - "020022000d030c070b2000410b6a2201417871210541b085c0002802002208450d" - "06411f2107410020056b2103200041f4ffff074d04402005410620014108766722" - "006b7641017120004101746b413e6a21070b2007410274419482c0006a28020022" - "0245044041002100410021010c040b4100210020054100411920074101766b2007" - "411f461b7421044100210103400240200228020441787122062005490d00200620" - "056b220620034f0d0020022101200622030d0041002103200221000c060b200228" - "021422062000200620022004411d764104716a41106a2802002202471b20002006" - "1b21002004410174210420020d000b0c030b02402001417f7341017120006a2206" - "410374220041a483c0006a2203200041ac83c0006a280200220128020822044704" - "402004200336020c200320043602080c010b41ac85c0002002417e200677713602" - "000b20012000410372360204200020016a220020002802044101723602040c060b" - "024041022000742203410020036b72200120007471682206410374220041a483c0" - "006a2203200041ac83c0006a280200220128020822044704402004200336020c20" - "0320043602080c010b41ac85c0002002417e200677713602000b20012005410372" - "360204200120056a2206200020056b2204410172360204200020016a2004360200" - "41b485c00028020022020440200241787141a483c0006a210041bc85c000280200" - "2103027f41ac85c0002802002205410120024103767422027145044041ac85c000" - "200220057236020020000c010b20002802080b2102200020033602082002200336" - "020c2003200036020c200320023602080b41bc85c000200636020041b485c00020" - "043602000c050b200068410274419482c0006a280200220128020441787120056b" - "2103200121020240034002400240200128021022000d00200128021422000d0020" - "022802182107024002402002200228020c22004604402002411441102002280214" - "22001b6a28020022010d01410021000c020b20022802082201200036020c200020" - "013602080c010b200241146a200241106a20001b21040340200421062001220041" - "146a200041106a200028021422011b210420004114411020011b6a28020022010d" - "000b200641003602000b2007450d032002200228021c410274419482c0006a2201" - "28020047044020074110411420072802102002461b6a20003602002000450d040c" - "020b2001200036020020000d0141b085c00041b085c000280200417e200228021c" - "77713602000c030b200028020441787120056b22012003200120034922011b2103" - "2000200220011b2102200021010c010b0b20002007360218200228021022010440" - "20002001360210200120003602180b20022802142201450d002000200136021420" - "0120003602180b02400240200341104f044020022005410372360204200220056a" - "22062003410172360204200320066a200336020041b485c0002802002204450d01" - "200441787141a483c0006a210041bc85c0002802002101027f41ac85c000280200" - "2205410120044103767422047145044041ac85c000200420057236020020000c01" - "0b20002802080b2104200020013602082004200136020c2001200036020c200120" - "043602080c010b2002200320056a2200410372360204200020026a220020002802" - "044101723602040c010b41bc85c000200636020041b485c00020033602000b2002" - "41086a0f0b20002001724504404100210141022007742200410020006b72200871" - "2200450d03200068410274419482c0006a28020021000b2000450d010b03402000" - "20012000280204417871220420056b220620034922071b21082000280210220245" - "0440200028021421020b20012008200420054922001b210120032006200320071b" - "20001b2103200222000d000b0b2001450d00200541b485c00028020022004d2003" - "200020056b4f710d0020012802182107024002402001200128020c220046044020" - "0141144110200128021422001b6a28020022020d01410021000c020b2001280208" - "2202200036020c200020023602080c010b200141146a200141106a20001b210403" - "40200421062002220041146a200041106a200028021422021b2104200041144110" - "20021b6a28020022020d000b200641003602000b02402007450d00024020012001" - "28021c410274419482c0006a220228020047044020074110411420072802102001" - "461b6a20003602002000450d020c010b2002200036020020000d0041b085c00041" - "b085c000280200417e200128021c77713602000c010b2000200736021820012802" - "102202044020002002360210200220003602180b20012802142202450d00200020" - "02360214200220003602180b0240200341104f0440200120054103723602042001" - "20056a22022003410172360204200220036a200336020020034180024f04402002" - "200310070c020b200341f8017141a483c0006a2100027f41ac85c0002802002204" - "410120034103767422037145044041ac85c000200320047236020020000c010b20" - "002802080b2103200020023602082003200236020c2002200036020c2002200336" - "02080c010b2001200320056a2200410372360204200020016a2200200028020441" - "01723602040b0c010b024002400240024002400240200541b485c0002802002201" - "4b0440200541b885c00028020022004f044041002100200541af80046a22014110" - "7640002202417f4622030d0720024110742202450d0741c485c000410020014180" - "807c7120031b220441c485c0002802006a220036020041c885c00041c885c00028" - "02002201200020002001491b3602000240024041c085c000280200220304404194" - "83c0002100034020002802002201200028020422066a2002460d02200028020822" - "000d000b0c020b41d085c00028020022004100200020024d1b45044041d085c000" - "20023602000b41d485c00041ff1f360200419883c0002004360200419483c00020" - "0236020041b083c00041a483c00036020041b883c00041ac83c00036020041ac83" - "c00041a483c00036020041c083c00041b483c00036020041b483c00041ac83c000" - "36020041c883c00041bc83c00036020041bc83c00041b483c00036020041d083c0" - "0041c483c00036020041c483c00041bc83c00036020041d883c00041cc83c00036" - "020041cc83c00041c483c00036020041e083c00041d483c00036020041d483c000" - "41cc83c00036020041e883c00041dc83c00036020041dc83c00041d483c0003602" - "0041a083c000410036020041f083c00041e483c00036020041e483c00041dc83c0" - "0036020041ec83c00041e483c00036020041f883c00041ec83c00036020041f483" - "c00041ec83c000360200418084c00041f483c00036020041fc83c00041f483c000" - "360200418884c00041fc83c000360200418484c00041fc83c000360200419084c0" - "00418484c000360200418c84c000418484c000360200419884c000418c84c00036" - "0200419484c000418c84c00036020041a084c000419484c000360200419c84c000" - "419484c00036020041a884c000419c84c00036020041a484c000419c84c0003602" - "0041b084c00041a484c00036020041b884c00041ac84c00036020041ac84c00041" - "a484c00036020041c084c00041b484c00036020041b484c00041ac84c000360200" - "41c884c00041bc84c00036020041bc84c00041b484c00036020041d084c00041c4" - "84c00036020041c484c00041bc84c00036020041d884c00041cc84c00036020041" - "cc84c00041c484c00036020041e084c00041d484c00036020041d484c00041cc84" - "c00036020041e884c00041dc84c00036020041dc84c00041d484c00036020041f0" - "84c00041e484c00036020041e484c00041dc84c00036020041f884c00041ec84c0" - "0036020041ec84c00041e484c000360200418085c00041f484c00036020041f484" - "c00041ec84c000360200418885c00041fc84c00036020041fc84c00041f484c000" - "360200419085c000418485c000360200418485c00041fc84c000360200419885c0" - "00418c85c000360200418c85c000418485c00036020041a085c000419485c00036" - "0200419485c000418c85c00036020041a885c000419c85c000360200419c85c000" - "419485c00036020041c085c000200236020041a485c000419c85c00036020041b8" - "85c000200441286b220036020020022000410172360204200020026a4128360204" - "41cc85c00041808080013602000c080b200220034d200120034b720d0020002802" - "0c450d030b41d085c00041d085c0002802002200200220002002491b3602002002" - "20046a2101419483c0002100024002400340200120002802002206470440200028" - "020822000d010c020b0b200028020c450d010b419483c000210003400240200320" - "0028020022014f04402003200120002802046a2206490d010b200028020821000c" - "010b0b41c085c000200236020041b885c000200441286b22003602002002200041" - "0172360204200020026a412836020441cc85c00041808080013602002003200641" - "206b41787141086b22002000200341106a491b2201411b360204419483c0002902" - "002109200141106a419c83c00029020037020020012009370208419883c0002004" - "360200419483c0002002360200419c83c000200141086a36020041a083c0004100" - "3602002001411c6a2100034020004107360200200041046a22002006490d000b20" - "012003460d0720012001280204417e713602042003200120036b22004101723602" - "042001200036020020004180024f04402003200010070c080b200041f8017141a4" - "83c0006a2101027f41ac85c0002802002202410120004103767422007145044041" - "ac85c000200020027236020020010c010b20012802080b21002001200336020820" - "00200336020c2003200136020c200320003602080c070b20002002360200200020" - "0028020420046a360204200220054103723602042006410f6a41787141086b2201" - "200220056a22046b2103200141c085c000280200460d03200141bc85c000280200" - "460d04200128020422054103714101460440200120054178712200100820002001" - "6a22012802042105200020036a21030b20012005417e7136020420042003410172" - "360204200320046a200336020020034180024f04402004200310070c060b200341" - "f8017141a483c0006a2100027f41ac85c000280200220141012003410376742203" - "7145044041ac85c000200120037236020020000c010b20002802080b2103200020" - "043602082003200436020c2004200036020c200420033602080c050b41b885c000" - "200020056b220136020041c085c00041c085c000280200220020056a2202360200" - "2002200141017236020420002005410372360204200041086a21000c060b41bc85" - "c00028020021000240200120056b2202410f4d044041bc85c000410036020041b4" - "85c000410036020020002001410372360204200020016a22012001280204410172" - "3602040c010b41b485c000200236020041bc85c000200020056a22033602002003" - "2002410172360204200020016a2002360200200020054103723602040b20004108" - "6a0f0b2000200420066a36020441c085c00041c085c0002802002200410f6a4178" - "71220141086b220236020041b885c00041b885c00028020020046a220320002001" - "6b6a41086a220136020020022001410172360204200020036a412836020441cc85" - "c00041808080013602000c030b41c085c000200436020041b885c00041b885c000" - "28020020036a2200360200200420004101723602040c010b41bc85c00020043602" - "0041b485c00041b485c00028020020036a22003602002004200041017236020420" - "0020046a20003602000b200241086a0f0b4100210041b885c00028020022012005" - "4d0d0041b885c000200120056b220136020041c085c00041c085c0002802002200" - "20056a22023602002002200141017236020420002005410372360204200041086a" - "0f0b20000f0b200141086a0ba203010b7f418882c0002d00001a41221001220704" - "402007410020076b41037122026a21062002044020072103418080c00021050340" - "200320052d00003a0000200541016a2105200341016a22032006490d000b0b2006" - "412220026b220b417c71220a6a210302402002418080406b22024103710440200a" - "41004c0d0120024103742208411871210c2002417c71220541046a210441002008" - "6b411871210820052802002105034020062005200c762004280200220520087472" - "360200200441046a2104200641046a22062003490d000b0c010b200a41004c0d00" - "20022104034020062004280200360200200441046a2104200641046a2206200349" - "0d000b0b2002200a6a2104200b41037122020440200220036a2102034020032004" - "2d00003a0000200441016a2104200341016a22032002490d000b0b200104402001" - "4122460440200021032007210241002105412221080240034020032d0000220920" - "022d00002204460440200341016a2103200241016a2102200841016b22080d010c" - "020b0b200920046b21050b20054521090b2000200110030b20074122100320090f" - "0b000bd20601047f0240200041046b280200220241787122034104410820024103" - "7122021b20016a4f0440200241002003200141276a4b1b0d01200041086b220120" - "0041046b280200220341787122006a21020240024020034101710d002003410271" - "450d012001280200220320006a2100200120036b220141bc85c000280200460440" - "20022802044103714103470d0141b485c000200036020020022002280204417e71" - "36020420012000410172360204200220003602000c020b2001200310080b024002" - "4002400240024020022802042203410271450440200241c085c000280200460d02" - "200241bc85c000280200460d0320022003417871220210082001200020026a2200" - "410172360204200020016a2000360200200141bc85c000280200470d0141b485c0" - "0020003602000c060b20022003417e713602042001200041017236020420002001" - "6a20003602000b2000418002490d022001200010074100210141d485c00041d485" - "c00028020041016b220036020020000d04419c83c0002802002200044003402001" - "41016a2101200028020822000d000b0b41d485c000200141ff1f200141ff1f4b1b" - "3602000c040b41c085c000200136020041b885c00041b885c00028020020006a22" - "003602002001200041017236020441bc85c000280200200146044041b485c00041" - "0036020041bc85c00041003602000b200041cc85c00028020022034d0d0341c085" - "c0002802002202450d034100210041b885c00028020022044129490d02419483c0" - "00210103402002200128020022054f04402002200520012802046a490d040b2001" - "28020821010c000b000b41bc85c000200136020041b485c00041b485c000280200" - "20006a220036020020012000410172360204200020016a20003602000c020b2000" - "41f8017141a483c0006a2102027f41ac85c0002802002203410120004103767422" - "007145044041ac85c000200020037236020020020c010b20022802080b21002002" - "20013602082000200136020c2001200236020c200120003602080c010b419c83c0" - "00280200220104400340200041016a2100200128020822010d000b0b41d485c000" - "200041ff1f200041ff1f4b1b360200200320044f0d0041cc85c000417f3602000b" - "0f0b418981c00041b881c0001004000b41c881c00041f881c0001004000b410101" - "7f230041206b220224002002410036021020024101360204200242043702082002" - "412e36021c200220003602182002200241186a360200200220011005000ba40201" - "037f230041206b22022400200241106a2203200041106a29020037030020024108" - "6a2204200041086a290200370300200241013b011c200220013602182002200029" - "0200370300230041206b2200240020022802182101200041106a20032902003703" - "00200041086a20042902003703002000200236021c200020013602182000200229" - "020037030041002102230041106b22012400200028020c21030240024002400240" - "20002802040e020001020b20030d01410121030c020b20030d0020002802002203" - "2802042102200328020021030c010b20014180808080783602002001200036020c" - "20014101200028021c22002d001c20002d001d1009000b20012002360204200120" - "0336020020014102200028021c22002d001c20002d001d1009000b090020004100" - "3602000bba0201047f411f210220004200370210200141ffffff074d0440200141" - "0620014108766722036b7641017120034101746b413e6a21020b2000200236021c" - "2002410274419482c0006a21044101200274220341b085c0002802007145044020" - "042000360200200020043602182000200036020c2000200036020841b085c00041" - "b085c0002802002003723602000f0b024002402001200428020022032802044178" - "71460440200321020c010b20014100411920024101766b2002411f461b74210503" - "4020032005411d764104716a41106a22042802002202450d022005410174210520" - "02210320022802044178712001470d000b0b20022802082201200036020c200220" - "00360208200041003602182000200236020c200020013602080f0b200420003602" - "00200020033602182000200036020c200020003602080bf10201047f200028020c" - "21020240024020014180024f044020002802182103024002402000200246044020" - "0041144110200028021422021b6a28020022010d01410021020c020b2000280208" - "2201200236020c200220013602080c010b200041146a200041106a20021b210403" - "40200421052001220241146a200241106a200228021422011b2104200241144110" - "20011b6a28020022010d000b200541003602000b2003450d022000200028021c41" - "0274419482c0006a220128020047044020034110411420032802102000461b6a20" - "023602002002450d030c020b2001200236020020020d0141b085c00041b085c000" - "280200417e200028021c77713602000c020b200028020822002002470440200020" - "0236020c200220003602080f0b41ac85c00041ac85c000280200417e2001410376" - "77713602000f0b2002200336021820002802102201044020022001360210200120" - "023602180b20002802142200450d0020022000360214200020023602180b0b7b01" - "017f230041106b22032400419082c000419082c000280200220441016a36020002" - "4020044100480d00024041dc85c0002d000045044041d885c00041d885c0002802" - "0041016a360200418c82c00028020041004e0d010c020b200341086a2000200111" - "0000000b41dc85c00041003a00002002450d00000b000b0c002000200129020037" - "03000b0b8f020100418080c0000b850272486239434a4157794234726a39315652" - "576e3936446b756b4734627764747954686361706163697479206f766572666c6f" - "77002200100011000000616c6c6f632f7372632f7261775f7665632e72733c0010" - "001400000018000000050000002f727573742f646570732f646c6d616c6c6f632d" - "302e322e362f7372632f646c6d616c6c6f632e7273617373657274696f6e206661" - "696c65643a207073697a65203e3d2073697a65202b206d696e5f6f766572686561" - "64006000100029000000a804000009000000617373657274696f6e206661696c65" - "643a207073697a65203c3d2073697a65202b206d61785f6f766572686561640000" - "6000100029000000ae0400000d00550970726f64756365727302086c616e677561" - "6765010452757374000c70726f6365737365642d62790105727573746325312e38" - "332e302d6e696768746c79202863326637346333663920323032342d30392d3039" - "2900490f7461726765745f6665617475726573042b0f6d757461626c652d676c6f" - "62616c732b087369676e2d6578742b0f7265666572656e63652d74797065732b0a" - "6d756c746976616c7565"; - -extern std::string const compareJsonHex = - "0061736d0100000001791160017f0060037f7f7f017f60027f7f017f60027f7f00" - "60037f7f7f0060047f7f7f7f0060017f017f60047f7f7f7e0060057f7f7f7e7f00" - "60057f7f7f7f7f0060047f7f7f7f017f60000060037e7f7f017f60067f7f7f7f7f" - "7f017f60057f7f7f7f7f017f60077f7f7f7f7f7f7f017f60067f7f7f7f7f7f0003" - "616004030305060001070808080809040702000000040403030304030500020306" - "0a0609000b0300040103030402040c000d0e04010202010204040f090902020204" - "0903020201020200000405000203030402020205100b0303000005030101010104" - "05017001121205030100110619037f01418080c0000b7f004195d3c0000b7f0041" - "a0d3c0000b074405066d656d6f7279020008616c6c6f63617465001e11636f6d70" - "6172655f6163636f756e744944001f0a5f5f646174615f656e6403010b5f5f6865" - "61705f6261736503020917010041010b1134332b3c3d3e4345565b124247445251" - "460ad3cf0260ea0301057f23808080800041e0006b220324808080800020034100" - "360228200320023602242003200136022020034180013a002c2003410036021c20" - "03428080808010370214200341c8006a200341146a108180808000024002400240" - "024020032d00484106460d00200341306a41106a2204200341c8006a41106a2903" - "00370300200341306a41086a2205200341c8006a41086a29030037030020032003" - "2903483703300240024020032802282202200328022422064f0d00200328022021" - "070340200720026a2d000041776a220141174b0d02410120017441938080047145" - "0d022006200241016a2202470d000b200320063602280b20002003290330370300" - "200041106a2004290300370300200041086a200529030037030020032802142202" - "450d04200328021820021082808080000c040b20032002360228200341086a2007" - "20062006200241016a220220062002491b10838080800041002d00c0cfc080001a" - "200328020c21012003280208210641141084808080002202450d01200220063602" - "0c2002411636020020002002360204200041063a00002002200136021020034130" - "6a1085808080000c020b2000200328024c360204200041063a00000c010b000b20" - "032802142202450d00200328021820021082808080000b200341e0006a24808080" - "80000beb28020c7f037e2380808080004180036b2202248080808000200128020c" - "210302400240024002400240024002400240024002400240024002400240024002" - "400240024002400240024002400240024002400240024002400240200128021422" - "04200128021022054f0d002001410c6a21060340200320046a2d0000220741776a" - "220841174b0d024101200874419380800471450d022001200441016a2204360214" - "20052004470d000b200521040b200241f0006a200320052005200441016a220420" - "052004491b10838080800041002d00c0cfc080001a200228027421082002280270" - "2101411410848080800022040d010c1b0b200741e5004a0d0820074122460d0620" - "07412d460d07200741db00470d09200120012d0018417f6a22083a001820044101" - "6a2104200841ff0171450d0520012004360214200241003602e002200242808080" - "8080013702d80241082109200420054f0d02200241b0016a41086a210a200241b0" - "016a410172210b410821094100210c4101210d0340200628020021030240034020" - "0320046a2d0000220741776a220841174b0d014101200874419380800471450d01" - "2001200441016a220436021420052004470d000b200521040c040b024002400240" - "200741dd00460d00200d4101710d02200441016a210402402007412c470d002001" - "20043602140240200420054f0d000340200320046a2d0000220741776a22084117" - "4b0d044101200874419380800471450d042001200441016a220436021420052004" - "470d000b200521040b200241386a200320052005200441016a220420052004491b" - "10838080800041002d00c0cfc080001a200228023c210420022802382108411410" - "84808080002207450d1f2007200836020c20074105360200200720043602100c08" - "0b200241c8006a200320052005200420052004491b10838080800041002d00c0cf" - "c080001a200228024c21042002280248210841141084808080002207450d1e2007" - "200836020c20074107360200200720043602100c070b20022902dc02210e200228" - "02d802210741042106410021090c070b200741dd00470d00200241c0006a200320" - "052005200441016a220420052004491b10838080800041002d00c0cfc080001a20" - "0228024421042002280240210841141084808080002207450d1c2007200836020c" - "20074115360200200720043602100c050b200241b0016a20011081808080000240" - "20022d00b00122084106470d0020022802b40121070c050b200241d4026a41026a" - "2205200b41026a2d00003a0000200241c0026a41086a2203200a41086a29030037" - "03002002200b2f00003b01d4022002200a2903003703c00220022802b401210702" - "40200c20022802d802470d00200241d8026a1090808080000b20022802dc022209" - "200c41186c6a220420022903c002370308200420083a0000200420022f01d4023b" - "000120042007360204200441106a2003290300370300200441036a20052d00003a" - "00002002200c41016a220c3602e0024100210d2001280214220420012802102205" - "4f0d020c000b0b2004200136020c2004410536020020002004360204200041063a" - "0000200420083602100c180b200628020021030b200241306a2003200520052004" - "41016a220420052004491b10838080800041002d00c0cfc080001a200228023421" - "042002280230210841141084808080002207450d172007200836020c2007410236" - "0200200720043602100b200241d8026a109180808000024020022802d802220445" - "0d002009200441186c1082808080000b200128020c210320012802142104200128" - "0210210541062106410121090b200120012d001841016a3a001802400240200420" - "054f0d0003400240024002400240024002400240200320046a2d00002208410c4a" - "0d00200841776a4102490d060c010b02402008411f4a0d002008410d470d010c06" - "0b20084120460d052008412c460d01200841dd00460d020b200241106a20032005" - "2005200441016a220420052004491b10838080800041002d00c0cfc080001a2002" - "28021421082002280210210541141084808080002204450d1d200441163602000c" - "070b2001200441016a2204360214200420054f0d020340200320046a2d0000220c" - "41776a220841174b0d024101200874419380800471450d022001200441016a2204" - "36021420052004470d000b200521040c020b2001200441016a3602142002200e37" - "03b801200220073602b401200220063a00b00102402009450d00200241063a0078" - "2002200736027c0c180b200241f8006a41106a200241b0016a41106a2903003703" - "00200241f8006a41086a200241b0016a41086a290300370300200220022903b001" - "3703780c170b200c41dd00470d00200241286a200320052005200441016a220420" - "052004491b10838080800041002d00c0cfc080001a200228022c21082002280228" - "210541141084808080002204450d1a200441153602000c040b200241206a200320" - "052005200441016a220420052004491b10838080800041002d00c0cfc080001a20" - "0228022421082002280220210541141084808080002204450d1920044116360200" - "0c030b2001200441016a220436021420052004470d000b200521040b200241186a" - "200320052005200441016a220420052004491b10838080800041002d00c0cfc080" - "001a200228021c21082002280218210541141084808080002204450d1620044102" - "3602000b2004200536020c20042008360210200220043602c8012002200e3703b8" - "01200220073602b401200220063a00b001024020090d00200241063a0078200220" - "0436027c200241b0016a1085808080000c120b200241063a00782002200736027c" - "200241c8016a1092808080000c110b200241086a20032005200520042005200449" - "1b10838080800041002d00c0cfc080001a200228020c2108200228020821014114" - "1084808080002204450d142004200136020c200441183602002000200436020420" - "0041063a0000200420083602100c130b200141003602082001200441016a360214" - "200241b0016a2006200110938080800020022802b40121080240024020022802b0" - "0122054102460d0020022802b8012104024020050d00200241f8006a2008200410" - "948080800020022d00784106460d1320002002290378370300200041106a200241" - "f8006a41106a290300370300200041086a200241f8006a41086a2903003703000c" - "150b41002101024020044100480d00024020040d0041012101410021050c030b41" - "002d00c0cfc080001a20042105200410848080800022010d02410121010b200120" - "04109580808000000b200041063a0000200020083602040c130b200241f8006a41" - "086a220320012008200410df808080003602002002200536027c200241033a0078" - "2002200436028401200041106a200241f8006a41106a290300370300200041086a" - "2003290300370300200020022903783703000c120b2001200441016a3602142002" - "4190016a20014100108d8080800002402002290390014203510d00200241f8006a" - "20024190016a109680808000024020022d00784106460d00200020022903783703" - "00200041106a200241f8006a41106a290300370300200041086a200241f8006a41" - "086a2903003703000c130b200228027c2001108f808080002104200041063a0000" - "200020043602040c120b2000200228029801360204200041063a00000c110b0240" - "200741f3004a0d00200741e600460d04200741ee00470d012001200441016a3602" - "14200141bb80c0800041031086808080002204450d02200041063a000020002004" - "3602040c110b200741f400460d02200741fb00460d040b200741506a41ff017141" - "0a490d042002200320052005200441016a220420052004491b1083808080004100" - "2d00c0cfc080001a20022802042108200228020021054114108480808000220445" - "0d102004200536020c2004410a360200200420083602102002200436027c0c0d0b" - "200241003a007820002002290378370300200041086a200241f8006a41086a2903" - "00370300200041106a200241f8006a41106a2903003703000c0e0b200120044101" - "6a3602140240200141be80c0800041031086808080002204450d00200041063a00" - "00200020043602040c0e0b20024181023b01782000200229037837030020004108" - "6a200241f8006a41086a290300370300200041106a200241f8006a41106a290300" - "3703000c0d0b2001200441016a3602140240200141c180c0800041041086808080" - "002204450d00200041063a0000200020043602040c0d0b200241013b0178200020" - "02290378370300200041086a200241f8006a41086a290300370300200041106a20" - "0241f8006a41106a2903003703000c0c0b200120012d0018417f6a22083a001820" - "0441016a2104200841ff0171450d0720012004360214200241013a00d801200220" - "013602d401200241b0016a200241d4016a10978080800002400240024020022d00" - "b0010d004105210620022d00b1010d01410021074200210e0c020b20022802b401" - "21070c070b20022802d401220441003602082004200428021441016a3602142002" - "41b0016a2004410c6a200410938080800020022802b401210720022802b0014102" - "460d06200241d8026a200720022802b801109880808000024020022802d8022204" - "418080808078470d0020022802dc0221070c070b20022802dc0221080240200441" - "8180808078470d00200821070c070b20022802e0022105200241003602e4012002" - "41003602dc01200220053602e002200220083602dc02200220043602d802200241" - "e8016a200241d4016a10998080800020022d00e8014106460d04200241b0016a20" - "0241dc016a200241d8026a200241e8016a109a80808000024020022d00b0014106" - "460d00200241b0016a1085808080000b20024180026a41046a2108200241b0016a" - "41046a21050340200241b0016a200241d4016a10978080800020022d00b0010d03" - "024020022d00b101450d0020022802d40122044100360208200420042802144101" - "6a360214200241b0016a2004410c6a200410938080800020022802b40121072002" - "2802b0014102460d07200241f4026a200720022802b80110988080800002402002" - "2802f4022204418080808078470d0020022802f80221070c080b20022802f80221" - "072004418180808078460d0720022802fc022103200241b0016a200241d4016a10" - "9980808000024020022d00b0014106470d0020022802b401210802402004450d00" - "200720041082808080000b200821070c080b200241d8026a41106a200241b0016a" - "41106a2209290300220e370300200241d8026a41086a200241b0016a41086a220c" - "290300220f370300200220022903b00122103703d802200541106a200e37020020" - "0541086a200f3702002005201037020020024180026a41086a200c290200370300" - "20024180026a41106a200929020037030020024180026a41186a200241b0016a41" - "186a280200360200200220022902b00137038002200220033602a4022002200736" - "02a0022002200436029c02200241a8026a41106a200841106a2902003703002002" - "41a8026a41086a200841086a290200370300200220082902003703a802200241b0" - "016a200241dc016a2002419c026a200241a8026a109a8080800020022d00b00141" - "06460d01200241b0016a1085808080000c010b0b20022802dc01210720022902e0" - "01210e0b410021090c060b200241a0016a20014101108d8080800020022903a001" - "4203510d01200241f8006a200241a0016a109680808000024020022d0078410646" - "0d0020002002290378370300200041106a200241f8006a41106a29030037030020" - "0041086a200241f8006a41086a2903003703000c0b0b200228027c2001108f8080" - "80002104200041063a0000200020043602040c0a0b20022802b40121070c020b20" - "0020022802a801360204200041063a00000c080b20022802ec0121072004450d00" - "200820041082808080000b200241dc016a109b808080000b41062106410121090b" - "200120012d001841016a3a0018200128020c210302400240024020012802142204" - "200128021022054f0d00034002400240200320046a2d00002208410c4a0d002008" - "41776a4102490d010c040b02402008411f4a0d002008410d470d040c010b200841" - "20460d0002402008412c460d00200841fd00470d042001200441016a3602144100" - "21040c050b200241e8006a200320052005200441016a220420052004491b108380" - "80800041002d00c0cfc080001a200228026c210820022802682105411410848080" - "80002204450d0a2004200536020c20044115360200200420083602100c040b2001" - "200441016a220436021420052004470d000b200521040b200241e0006a20032005" - "2005200441016a220420052004491b10838080800041002d00c0cfc080001a2002" - "28026421082002280260210541141084808080002204450d072004200536020c20" - "044103360200200420083602100c010b200241d8006a200320052005200441016a" - "220420052004491b10838080800041002d00c0cfc080001a200228025c21082002" - "280258210541141084808080002204450d062004200536020c2004411636020020" - "0420083602100b200220063a00b001200220022f00d8023b00b101200220043602" - "c8012002200e3703b801200220073602b4012002200241da026a2d00003a00b301" - "024020090d00024020040d00200241f8006a41106a200241b0016a41106a290300" - "370300200241f8006a41086a200241b0016a41086a290300370300200220022903" - "b0013703780c030b200241063a00782002200436027c200241b0016a1085808080" - "000c020b200241063a00782002200736027c2004450d01200241c8016a10928080" - "80000c010b200241d0006a200320052005200420052004491b1083808080004100" - "2d00c0cfc080001a20022802542108200228025021014114108480808000220445" - "0d042004200136020c2004411836020020002004360204200041063a0000200420" - "083602100c030b20022d00784106470d010b200228027c2001108f808080002104" - "200041063a0000200020043602040c010b20002002290378370300200041106a20" - "0241f8006a41106a290300370300200041086a200241f8006a41086a2903003703" - "000b20024180036a2480808080000f0b000b7001027f024002402000417c6a2802" - "002202417871220341044108200241037122021b20016a490d0002402002450d00" - "2003200141276a4b0d020b200010a5808080000f0b41c9c5c08000412e41f8c5c0" - "800010a680808000000b4188c6c08000412e41b8c6c0800010a680808000000be6" - "0301057f02400240024002400240024020022003490d0041012104410021052003" - "4101480d04200120036a21060240200341034b0d000340200620014d0d06200641" - "7f6a22062d0000410a470d000c050b0b024041808284082006417c6a2800002207" - "418a94a8d000736b20077241808182847871418081828478460d00034020062001" - "4d0d062006417f6a22062d0000410a470d000c050b0b200320064103716b210720" - "034109490d0103400240024020074108480d004180828408200120076a22064178" - "6a2802002208418a94a8d000736b20087241808182847871418081828478460d01" - "0b200120076a21060c040b200741786a210741808284082006417c6a2802002208" - "418a94a8d000736b20087241808182847871418081828478460d000c030b0b2003" - "20024188bcc0800010b180808000000b200120076a21060340200620014d0d0320" - "06417f6a22062d0000410a470d000c020b0b0340200620014d0d022006417f6a22" - "062d0000410a470d000b0b200620016b41016a220520024b0d010b024020012005" - "6a20014d0d0041002106200521070340200620012d0000410a466a210620014101" - "6a21012007417f6a22070d000b200641016a21040b200020043602002000200320" - "056b3602040f0b200520024198bcc0800010b180808000000bc12502087f017e02" - "400240024002400240024002400240200041f4014b0d0041002802e4d2c0800022" - "0141102000410b6a41f803712000410b491b220241037622037622004103710d01" - "200241002802ecd2c080004d0d0720000d0241002802e8d2c0800022000d030c07" - "0b2000410b6a2203417871210241002802e8d2c080002204450d06411f21050240" - "200041f4ffff074b0d002002410620034108766722006b7641017120004101746b" - "413e6a21050b410020026b21030240200541027441cccfc080006a28020022010d" - "0041002100410021060c040b4100210020024100411920054101766b2005411f46" - "1b74210741002106034002402001220128020441787122082002490d0020082002" - "6b220820034f0d00200821032001210620080d004100210320012106200121000c" - "060b200128021422082000200820012007411d764104716a41106a280200220147" - "1b200020081b2100200741017421072001450d040c000b0b024002402000417f73" - "41017120036a2207410374220041dcd0c080006a2202200041e4d0c080006a2802" - "0022032802082206460d002006200236020c200220063602080c010b4100200141" - "7e200777713602e4d2c080000b20032000410372360204200320006a2200200028" - "0204410172360204200341086a0f0b024002402000200374410220037422004100" - "20006b7271682208410374220341dcd0c080006a2206200341e4d0c080006a2802" - "0022002802082207460d002007200636020c200620073602080c010b4100200141" - "7e200877713602e4d2c080000b20002002410372360204200020026a2207200320" - "026b2202410172360204200020036a2002360200024041002802ecd2c080002201" - "450d00200141787141dcd0c080006a210641002802f4d2c0800021030240024041" - "002802e4d2c08000220841012001410376742201710d00410020082001723602e4" - "d2c08000200621010c010b200628020821010b200620033602082001200336020c" - "2003200636020c200320013602080b410020073602f4d2c08000410020023602ec" - "d2c08000200041086a0f0b20006841027441cccfc080006a280200220628020441" - "787120026b2103200621010240024003400240200628021022000d002006280214" - "22000d0020012802182105024002400240200128020c22002001470d0020014114" - "4110200128021422001b6a28020022060d01410021000c020b2001280208220620" - "0036020c200020063602080c010b200141146a200141106a20001b210703402007" - "21082006220041146a200041106a200028021422061b210720004114411020061b" - "6a28020022060d000b200841003602000b2005450d030240200128021c41027441" - "cccfc080006a22062802002001460d0020054110411420052802102001461b6a20" - "003602002000450d040c030b2006200036020020000d02410041002802e8d2c080" - "00417e200128021c77713602e8d2c080000c030b200028020441787120026b2206" - "2003200620034922061b21032000200120061b2101200021060c000b0b20002005" - "360218024020012802102206450d0020002006360210200620003602180b200128" - "02142206450d0020002006360214200620003602180b0240024002402003411049" - "0d0020012002410372360204200120026a22022003410172360204200220036a20" - "0336020041002802ecd2c080002207450d01200741787141dcd0c080006a210641" - "002802f4d2c0800021000240024041002802e4d2c0800022084101200741037674" - "2207710d00410020082007723602e4d2c08000200621070c010b20062802082107" - "0b200620003602082007200036020c2000200636020c200020073602080c010b20" - "01200320026a2200410372360204200120006a220020002802044101723602040c" - "010b410020023602f4d2c08000410020033602ecd2c080000b200141086a0f0b02" - "4020002006720d004100210641022005742200410020006b722004712200450d03" - "20006841027441cccfc080006a28020021000b2000450d010b0340200020062000" - "280204417871220120026b220820034922051b2104200120024921072008200320" - "051b21080240200028021022010d00200028021421010b2006200420071b210620" - "03200820071b21032001210020010d000b0b2006450d00024041002802ecd2c080" - "0022002002490d002003200020026b4f0d010b2006280218210502400240024020" - "0628020c22002006470d00200641144110200628021422001b6a28020022010d01" - "410021000c020b20062802082201200036020c200020013602080c010b20064114" - "6a200641106a20001b21070340200721082001220041146a200041106a20002802" - "1422011b210720004114411020011b6a28020022010d000b200841003602000b02" - "402005450d0002400240200628021c41027441cccfc080006a2201280200200646" - "0d0020054110411420052802102006461b6a20003602002000450d020c010b2001" - "200036020020000d00410041002802e8d2c08000417e200628021c77713602e8d2" - "c080000c010b20002005360218024020062802102201450d002000200136021020" - "0120003602180b20062802142201450d0020002001360214200120003602180b02" - "40024020034110490d0020062002410372360204200620026a2200200341017236" - "0204200020036a200336020002402003418002490d002000200310d7808080000c" - "020b200341f8017141dcd0c080006a21020240024041002802e4d2c08000220141" - "012003410376742203710d00410020012003723602e4d2c08000200221030c010b" - "200228020821030b200220003602082003200036020c2000200236020c20002003" - "3602080c010b2006200320026a2200410372360204200620006a22002000280204" - "4101723602040b200641086a0f0b024002400240024002400240024041002802ec" - "d2c08000220020024f0d00024041002802f0d2c08000220020024b0d0041002100" - "200241af80046a220641107640002203417f4622070d0720034110742201450d07" - "410041002802fcd2c08000410020064180807c7120071b22086a22003602fcd2c0" - "800041004100280280d3c0800022032000200320004b1b360280d3c08000024002" - "40024041002802f8d2c080002203450d0041ccd0c0800021000340200028020022" - "06200028020422076a2001460d02200028020822000d000c030b0b024002404100" - "280288d3c080002200450d00200020014d0d010b41002001360288d3c080000b41" - "0041ff1f36028cd3c08000410020083602d0d0c08000410020013602ccd0c08000" - "410041dcd0c080003602e8d0c08000410041e4d0c080003602f0d0c08000410041" - "dcd0c080003602e4d0c08000410041ecd0c080003602f8d0c08000410041e4d0c0" - "80003602ecd0c08000410041f4d0c08000360280d1c08000410041ecd0c0800036" - "02f4d0c08000410041fcd0c08000360288d1c08000410041f4d0c080003602fcd0" - "c0800041004184d1c08000360290d1c08000410041fcd0c08000360284d1c08000" - "4100418cd1c08000360298d1c0800041004184d1c0800036028cd1c08000410041" - "94d1c080003602a0d1c080004100418cd1c08000360294d1c08000410041003602" - "d8d0c080004100419cd1c080003602a8d1c0800041004194d1c0800036029cd1c0" - "80004100419cd1c080003602a4d1c08000410041a4d1c080003602b0d1c0800041" - "0041a4d1c080003602acd1c08000410041acd1c080003602b8d1c08000410041ac" - "d1c080003602b4d1c08000410041b4d1c080003602c0d1c08000410041b4d1c080" - "003602bcd1c08000410041bcd1c080003602c8d1c08000410041bcd1c080003602" - "c4d1c08000410041c4d1c080003602d0d1c08000410041c4d1c080003602ccd1c0" - "8000410041ccd1c080003602d8d1c08000410041ccd1c080003602d4d1c0800041" - "0041d4d1c080003602e0d1c08000410041d4d1c080003602dcd1c08000410041dc" - "d1c080003602e8d1c08000410041e4d1c080003602f0d1c08000410041dcd1c080" - "003602e4d1c08000410041ecd1c080003602f8d1c08000410041e4d1c080003602" - "ecd1c08000410041f4d1c08000360280d2c08000410041ecd1c080003602f4d1c0" - "8000410041fcd1c08000360288d2c08000410041f4d1c080003602fcd1c0800041" - "004184d2c08000360290d2c08000410041fcd1c08000360284d2c080004100418c" - "d2c08000360298d2c0800041004184d2c0800036028cd2c0800041004194d2c080" - "003602a0d2c080004100418cd2c08000360294d2c080004100419cd2c080003602" - "a8d2c0800041004194d2c0800036029cd2c08000410041a4d2c080003602b0d2c0" - "80004100419cd2c080003602a4d2c08000410041acd2c080003602b8d2c0800041" - "0041a4d2c080003602acd2c08000410041b4d2c080003602c0d2c08000410041ac" - "d2c080003602b4d2c08000410041bcd2c080003602c8d2c08000410041b4d2c080" - "003602bcd2c08000410041c4d2c080003602d0d2c08000410041bcd2c080003602" - "c4d2c08000410041ccd2c080003602d8d2c08000410041c4d2c080003602ccd2c0" - "8000410041d4d2c080003602e0d2c08000410041ccd2c080003602d4d2c0800041" - "0020013602f8d2c08000410041d4d2c080003602dcd2c080004100200841586a22" - "003602f0d2c0800020012000410172360204200120006a41283602044100418080" - "8001360284d3c080000c080b200320014f0d00200620034b0d00200028020c450d" - "030b41004100280288d3c080002200200120002001491b360288d3c08000200120" - "086a210641ccd0c0800021000240024002400340200028020022072006460d0120" - "0028020822000d000c020b0b200028020c450d010b41ccd0c08000210002400340" - "02402000280200220620034b0d002003200620002802046a2206490d020b200028" - "020821000c000b0b410020013602f8d2c080004100200841586a22003602f0d2c0" - "800020012000410172360204200120006a412836020441004180808001360284d3" - "c080002003200641606a41787141786a22002000200341106a491b2207411b3602" - "0441002902ccd0c080002109200741106a41002902d4d0c0800037020020072009" - "370208410020083602d0d0c08000410020013602ccd0c080004100200741086a36" - "02d4d0c08000410041003602d8d0c080002007411c6a2100034020004107360200" - "200041046a22002006490d000b20072003460d0720072007280204417e71360204" - "2003200720036b22004101723602042007200036020002402000418002490d0020" - "03200010d7808080000c080b200041f8017141dcd0c080006a2106024002404100" - "2802e4d2c08000220141012000410376742200710d00410020012000723602e4d2" - "c08000200621000c010b200628020821000b200620033602082000200336020c20" - "03200636020c200320003602080c070b200020013602002000200028020420086a" - "360204200120024103723602042007410f6a41787141786a2206200120026a2200" - "6b2103200641002802f8d2c08000460d03200641002802f4d2c08000460d040240" - "200628020422024103714101470d0020062002417871220210a880808000200220" - "036a2103200620026a220628020421020b20062002417e71360204200020034101" - "72360204200020036a200336020002402003418002490d002000200310d7808080" - "000c060b200341f8017141dcd0c080006a21020240024041002802e4d2c0800022" - "0641012003410376742203710d00410020062003723602e4d2c08000200221030c" - "010b200228020821030b200220003602082003200036020c2000200236020c2000" - "20033602080c050b4100200020026b22033602f0d2c08000410041002802f8d2c0" - "8000220020026a22063602f8d2c080002006200341017236020420002002410372" - "360204200041086a21000c060b41002802f4d2c08000210302400240200020026b" - "2206410f4b0d00410041003602f4d2c08000410041003602ecd2c0800020032000" - "410372360204200320006a220020002802044101723602040c010b410020063602" - "ecd2c080004100200320026a22013602f4d2c08000200120064101723602042003" - "20006a2006360200200320024103723602040b200341086a0f0b2000200720086a" - "360204410041002802f8d2c080002200410f6a417871220341786a22063602f8d2" - "c080004100200020036b41002802f0d2c0800020086a22036a41086a22013602f0" - "d2c0800020062001410172360204200020036a4128360204410041808080013602" - "84d3c080000c030b410020003602f8d2c08000410041002802f0d2c0800020036a" - "22033602f0d2c08000200020034101723602040c010b410020003602f4d2c08000" - "410041002802ecd2c0800020036a22033602ecd2c0800020002003410172360204" - "200020036a20033602000b200141086a0f0b4100210041002802f0d2c080002203" - "20024d0d004100200320026b22033602f0d2c08000410041002802f8d2c0800022" - "0020026a22063602f8d2c080002006200341017236020420002002410372360204" - "200041086a0f0b20000b6801017f024002400240024020002d00000e0503030301" - "02000b200041046a109b808080000c020b20002802042201450d01200028020820" - "011082808080000f0b200041046a10918080800020002802042201450d00200028" - "0208200141186c1082808080000f0b0ba20201087f23808080800041106b220324" - "80808080002000280214220420002802102205200420054b1b2106200028020c21" - "0702400240024002400340024020020d00410021040c050b20062004460d012000" - "200441016a22083602142002417f6a2102200720046a210920012d0000210a2008" - "2104200141016a2101200a20092d0000460d000b200341086a2007200520081083" - "8080800041002d00c0cfc080001a200328020c2101200328020821024114108480" - "8080002204450d01200441093602000c020b200320072005200610838080800041" - "002d00c0cfc080001a200328020421012003280200210241141084808080002204" - "450d00200441053602000c010b000b2004200236020c200420013602100b200341" - "106a24808080800020040b970202027f027e23808080800041106b220424808080" - "8000024002400240024002400240024002402001280214220520012802104f0d00" - "200128020c20056a2d00002205412e460d01200541c500460d02200541e500460d" - "020b2002450d02420121060c050b20042001200220034100108880808000200428" - "02000d020c030b200420012002200341001089808080002004280200450d022000" - "2004280204360208200042033703000c040b420021060240420020037d22074200" - "590d0042022106200721030c030b2003babd428080808080808080807f8421030c" - "020b20002004280204360208200042033703000c020b2004290308210342002106" - "0b20002003370308200020063703000b200441106a2480808080000bfa0301097f" - "23808080800041106b220524808080800020012001280214220641016a22073602" - "140240024002402007200128021022084f0d00200720086b2109200128020c210a" - "410021060240024003400240200a20076a2d0000220b41506a220c41ff0171220d" - "410a490d00024020060d002005200a20082008200741016a220720082007491b10" - "838080800041002d00c0cfc080001a200528020421062005280200210c41141084" - "808080002207450d072007200c36020c2007410d36020020002007360204200041" - "01360200200720063602100c060b200620046a2107200b41207241e500470d0320" - "0020012002200320071089808080000c050b024020034298b3e6cc99b3e6cc1958" - "0d0020034299b3e6cc99b3e6cc19520d02200d41054b0d020b2001200741016a22" - "073602142006417f6a21062003420a7e200cad42ff01837c210320072008470d00" - "0b200920046a21070c010b2000200120022003200620046a108a808080000c020b" - "20002001200220032007108b808080000c010b200541086a200128020c20082008" - "200641026a220720082007491b10838080800041002d00c0cfc080001a20052802" - "0c21062005280208210c41141084808080002207450d012007200c36020c200741" - "053602002000200736020420004101360200200720063602100b200541106a2480" - "808080000f0b000bb80401077f23808080800041106b2205248080808000410121" - "0620012001280214220741016a220836021402402008200128021022094f0d0041" - "01210602400240200128020c20086a2d000041556a0e03010200020b410021060b" - "2001200741026a22083602140b200128020c210a02400240024002400240024002" - "40200820094f0d002001200841016a2207360214200a20086a2d000041506a41ff" - "01712208410a4f0d010240200720094f0d000340200a20076a2d000041506a41ff" - "0171220b410a4f0d012001200741016a22073602140240200841cb99b3e6004c0d" - "00200841cc99b3e600470d07200b41074b0d070b2008410a6c200b6a2108200920" - "07470d000b0b20060d02200420086b2207411f7541808080807873200720084100" - "4a2007200448731b21070c030b200541086a200a2009200810838080800041002d" - "00c0cfc080001a200528020c21012005280208210841141084808080002207450d" - "042007200836020c20074105360200200020073602042000410136020020072001" - "3602100c050b2005200a2009200710838080800041002d00c0cfc080001a200528" - "020421012005280200210841141084808080002207450d032007200836020c2007" - "410d3602002000200736020420004101360200200720013602100c040b20042008" - "6a2207411f7541808080807873200720084100482007200448731b21070b200020" - "01200220032007108b808080000c020b2000200120022003502006108c80808000" - "0c010b000b200541106a2480808080000b7f01047f024002402001280214220520" - "0128021022064f0d00200128020c210702400340200720056a2d0000220841506a" - "41ff017141094b0d012001200541016a220536021420062005470d000c020b0b20" - "0841207241e500460d010b20002001200220032004108b808080000f0b20002001" - "2002200320041089808080000b9f0304017f017c017f017c23808080800041106b" - "22052480808080002003ba2106024002400240024002400240024020042004411f" - "7522077320076b220741b502490d0003402006440000000000000000610d062004" - "417f4a0d02200644a0c8eb85f3cce17fa32106200441b4026a22042004411f7522" - "077320076b220741b4024b0d000b0b200741037441f0a6c080006a2b0300210820" - "04417f4a0d0120062008a321060c040b2005200128020c20012802102001280214" - "10838080800041002d00c0cfc080001a2005280204210720052802002101411410" - "84808080002204450d022004200136020c2004410e360200200020043602042004" - "20073602100c010b20062008a222069944000000000000f07f620d02200541086a" - "200128020c2001280210200128021410838080800041002d00c0cfc080001a2005" - "28020c21072005280208210141141084808080002204450d012004200136020c20" - "04410e36020020002004360204200420073602100b410121040c020b000b200020" - "0620069a20021b390308410021040b20002004360200200541106a248080808000" - "0b840201027f23808080800041106b220524808080800002400240024002402004" - "450d002003450d010b20012802142204200128021022034f0d01200128020c2106" - "0340200620046a2d000041506a41ff0171410a4f0d022001200441016a22043602" - "1420032004470d000c020b0b200541086a200128020c2001280210200128021410" - "838080800041002d00c0cfc080001a200528020c21012005280208210302404114" - "1084808080002204450d002004200336020c2004410e3602002000200436020420" - "042001360210410121040c020b000b200044000000000000000044000000000000" - "008020021b390308410021040b20002004360200200541106a2480808080000b95" - "0502067f017e23808080800041306b2203248080808000200128020c2104024002" - "40024002400240024020012802142205200128021022064f0d002001200541016a" - "2207360214200420056a2d000022084130470d020240200720064f0d0020042007" - "6a2d000041506a41ff0171410a490d020b20002001200242001087808080000c05" - "0b200341186a20042006200510838080800041002d00c0cfc080001a200328021c" - "21072003280218210441141084808080002201450d022001200436020c20014105" - "3602002000200136020820004203370300200120073602100c040b200341086a20" - "0420062006200541026a220120062001491b10838080800041002d00c0cfc08000" - "1a200328020c21072003280208210441141084808080002201450d012001200436" - "020c2001410d3602002000200136020820004203370300200120073602100c030b" - "02402008414f6a41ff01714109490d00200341106a200420062007108380808000" - "41002d00c0cfc080001a2003280214210720032802102104411410848080800022" - "01450d012001200436020c2001410d360200200020013602082000420337030020" - "0120073602100c030b200841506aad42ff01832109200720064f0d010340200420" - "076a2d000041506a220541ff01712208410a4f0d020240024020094299b3e6cc99" - "b3e6cc19540d0020094299b3e6cc99b3e6cc19520d01200841054b0d010b200120" - "0741016a22073602142009420a7e2005ad42ff01837c210920062007470d010c03" - "0b0b200341206a200120022009108e808080000240024020032802200d00200020" - "032b0328390308420021090c010b20002003280224360208420321090b20002009" - "3703000c020b000b20002001200220091087808080000b200341306a2480808080" - "000bbd0101057f410021040240024020012802102205200128021422064d0d0020" - "0641016a2107200520066b2108200128020c20066a210541002104034002402005" - "20046a2d0000220641506a41ff0171410a490d002006412e460d030240200641c5" - "00460d00200641e500470d030b200020012002200320041089808080000f0b2001" - "200720046a3602142008200441016a2204470d000b200821040b20002001200220" - "032004108b808080000f0b200020012002200320041088808080000bc80101047f" - "23808080800041206b2202248080808000024002400240200028020c450d002000" - "21010c010b200241106a41086a2203200041086a28020036020020022000290200" - "370310200241086a200128020c2001280210200128021410838080800041002d00" - "c0cfc080001a200228020c21042002280208210541141084808080002201450d01" - "200120022903103702002001200536020c20012004360210200141086a20032802" - "00360200200041141082808080000b200241206a24808080800020010f0b000b59" - "01017f23808080800041106b2201248080808000200141086a2000200028020041" - "014108411810d480808000024020012802082200418180808078460d0020002001" - "28020c109580808000000b200141106a2480808080000b950101027f0240200028" - "02082201450d00200028020441046a2100034002400240024002402000417c6a2d" - "00000e050303030102000b2000109b808080000c020b20002802002202450d0120" - "0041046a28020020021082808080000c010b200010918080800020002802002202" - "450d00200041046a280200200241186c1082808080000b200041186a2100200141" - "7f6a22010d000b0b0b970101047f024002400240200028020022002802000e0200" - "01020b20002802082201450d01200028020420011082808080000c010b20002d00" - "044103470d00200028020822012802002102024020012802042203280200220445" - "0d002002200411808080800080808080000b024020032802042203450d00200220" - "031082808080000b2001410c1082808080000b200041141082808080000b9b0d02" - "097f017e23808080800041306b2203248080808000024002400240024002400240" - "0240024002400340024002402001280208220420012802042205460d0002400240" - "0240200420054f0d002001280200220620046a2d000022074122460d01200741dc" - "00460d0120074120490d012006200441016a22086a21094100200520086b417871" - "220a6b210703402009210b024020070d002001200a20086a360208200110c88080" - "800020012802042105200128020821070c040b200741086a2107200b41086a2109" - "200b290000220c42a2c48891a2c48891228542fffdfbf7efdfbfff7e7c200c42e0" - "bffffefdfbf7ef5f7c84200c42dcb8f1e2c58b97aedc008542fffdfbf7efdfbfff" - "7e7c84200c427f858342808182848890a0c0807f83220c500d000b2001200b2006" - "6b200c7aa74103766a22073602080c020b2004200541a8bcc0800010ac80808000" - "0c080b200421070b20072005470d01200521040b200341086a2001280200200420" - "0410838080800041002d00c0cfc080001a200328020c210b200328020821094114" - "1084808080002207450d052007200936020c200741043602002000200736020420" - "0041023602002007200b3602100c0a0b024020072005490d002007200541b8bcc0" - "800010ac80808000000b02402001280200220b20076a2d0000220941dc00460d00" - "024020094122470d002002280208450d0520072004490d072002200b20046a2007" - "20046b10c9808080004101210b2001200741016a360208200341286a2001200228" - "0204200228020810ca8080800020032802282207450d032000200328022c360208" - "0c040b2001200741016a2207360208200341106a200b2005200710838080800041" - "002d00c0cfc080001a2003280214210b2003280210210941141084808080002207" - "450d052007200936020c2007411036020020002007360204200041023602002007" - "200b3602100c0a0b024020072004490d002002200b20046a200720046b10c98080" - "80002001200741016a2209360208024020092005490d00200341206a200b200520" - "0910838080800041002d00c0cfc080001a2003280224210b200328022021094114" - "1084808080002207450d06200741043602000c090b2001200741026a2204360208" - "02400240024002400240024002400240024002400240200b20096a2d0000220741" - "ed004a0d000240200741e1004a0d0020074122460d032007412f460d04200741dc" - "00470d020240200228020822072002280200470d00200210cb808080000b200220" - "0741016a360208200228020420076a41dc003a0000410021070c0b0b2007419e7f" - "6a0e050401010105010b200741927f6a0e080500000006000708000b200341186a" - "200b2005200410838080800041002d00c0cfc080001a200328021c210b20032802" - "18210941141084808080002207450d0e2007410c3602000c110b02402002280208" - "22072002280200470d00200210cb808080000b2002200741016a36020820022802" - "0420076a41223a0000410021070c070b0240200228020822072002280200470d00" - "200210cb808080000b2002200741016a360208200228020420076a412f3a000041" - "0021070c060b0240200228020822072002280200470d00200210cb808080000b20" - "02200741016a360208200228020420076a41083a0000410021070c050b02402002" - "28020822072002280200470d00200210cb808080000b2002200741016a36020820" - "0228020420076a410c3a0000410021070c040b0240200228020822072002280200" - "470d00200210cb808080000b2002200741016a360208200228020420076a410a3a" - "0000410021070c030b0240200228020822072002280200470d00200210cb808080" - "000b2002200741016a360208200228020420076a410d3a0000410021070c020b02" - "40200228020822072002280200470d00200210cb808080000b2002200741016a36" - "0208200228020420076a41093a0000410021070c010b2001200210cc8080800021" - "070b2007450d010c090b0b2004200741e8bcc0800010b780808000000b4102210b" - "200328022c21070b2000200b360200200020073602040c060b20072004490d0220" - "01200741016a360208200341286a2001200b20046a200720046b10ca8080800002" - "40024020032802282207450d002000200328022c3602084100210b0c010b410221" - "0b200328022c21070b2000200b360200200020073602040c050b000b2004200741" - "c8bcc0800010b780808000000b2004200741d8bcc0800010b780808000000b2007" - "200936020c2007200b3602100b20004102360200200020073602040b200341306a" - "2480808080000b7901027f410021030240024020024100480d00024020020d0041" - "002103410121040c020b41002d00c0cfc080001a20022103200210848080800022" - "040d01410121030b20032002109580808000000b20042001200210df8080800021" - "012000200236020c2000200136020820002003360204200041033a00000b100002" - "4020000d0010a3808080000b000b870102017c017e02400240024020012802000e" - "03000102000b20004202370308200020012b0308220239031020002002bd42ffff" - "ffffffffffffff00834280808080808080f8ff00534101743a00000f0b20004200" - "370308200041023a0000200020012903083703100f0b200041023a000020002001" - "290308220337031020002003423f883703080bb40701077f23808080800041306b" - "22022480808080002001280200220328020c210402400240024002402003280214" - "2205200341106a28020022064f0d000340200420056a2d0000220741776a220841" - "174b0d024101200874419380800471450d022003200541016a2205360214200620" - "05470d000b200621050b41012108200241286a200420062006200541016a220520" - "062005491b10838080800041002d00c0cfc080001a200228022c21062002280228" - "210341141084808080002205450d022005200336020c2005410336020020002005" - "360204200520063602100c010b0240200741fd00470d0041002108200041003a00" - "010c010b02400240024020012d00040d00200541016a21052007412c470d012003" - "20053602140240200520064f0d00034002400240024002400240200420056a2d00" - "002208410c4a0d00200841776a41024f0d010c040b0240200841606a0e03040102" - "000b2008410d460d03200841fd00460d020b41012108200241086a200420062006" - "200541016a220520062005491b10838080800041002d00c0cfc080001a20022802" - "0c21062002280208210341141084808080002205450d092005200336020c200541" - "1136020020002005360204200520063602100c080b200041013a0001410021080c" - "070b41012108200241186a200420062006200541016a220520062005491b108380" - "80800041002d00c0cfc080001a200228021c210620022802182103411410848080" - "80002205450d072005200336020c20054115360200200020053602042005200636" - "02100c060b2003200541016a220536021420062005470d000b200621050b410121" - "08200241106a200420062006200541016a220520062005491b1083808080004100" - "2d00c0cfc080001a20022802142106200228021021034114108480808000220545" - "0d042005200336020c2005410536020020002005360204200520063602100c030b" - "41002108200141003a0004024020074122460d002002200420062006200541016a" - "220520062005491b10838080800041002d00c0cfc080001a200228020421082002" - "280200210641141084808080002205450d042005200636020c2005411136020020" - "002005360204200520083602100c020b200041013a00010c020b200241206a2004" - "20062006200520062005491b10838080800041002d00c0cfc080001a2002280224" - "21082002280220210641141084808080002205450d022005200636020c20054108" - "36020020002005360204200520083602100b410121080b200020083a0000200241" - "306a2480808080000f0b000b7201027f410021030240024020024100480d000240" - "20020d0041002103410121040c020b41002d00c0cfc080001a2002210320021084" - "8080800022040d01410121030b20032002109580808000000b20042001200210df" - "8080800021012000200236020820002001360204200020033602000bdc0201067f" - "23808080800041106b22022480808080002001280200220328020c210402400240" - "02400240024020032802142201200341106a28020022054f0d000340200420016a" - "2d0000220641776a220741174b0d024101200774419380800471450d0220032001" - "41016a220136021420052001470d000b200521010b200241086a20042005200520" - "0141016a220120052001491b10838080800041002d00c0cfc080001a200228020c" - "21072002280208210541141084808080002201450d03200141033602000c010b02" - "402006413a470d002003200141016a360214200020031081808080000c020b2002" - "200420052005200141016a220120052001491b10838080800041002d00c0cfc080" - "001a200228020421072002280200210541141084808080002201450d0220014106" - "3602000b2001200536020c20002001360204200041063a0000200120073602100b" - "200241106a2480808080000f0b000be411020b7f027e23808080800041c0016b22" - "042480808080000240024002400240024002400240024002400240024002400240" - "20012802002205450d002002280208210620022802042107200128020421080240" - "03402005418c026a210920052f019203220a410c6c210b417f210c024002400340" - "0240200b0d00200a210c0c020b2009280208210d2009280204210e200c41016a21" - "0c200b41746a210b2009410c6a2109417f2007200e2006200d2006200d491b10dc" - "80808000220e2006200d6b200e1b220d410047200d4100481b220d4101460d000b" - "200d41ff0171450d010b2008450d022008417f6a21082005200c4102746a419803" - "6a28020021050c010b0b20022802002209450d0c200720091082808080000c0c0b" - "2002290204220fa721092002280200220b418080808078470d03200921050c010b" - "2002290204220fa721052002280200220d418080808078470d010b2001210c0c09" - "0b41002d00c0cfc080001a4198031084808080002209450d02200941013b019203" - "20094100360288022009200f422088a7ad4220862005ad84370390022009200d36" - "028c02200142808080801037020420012009360200200920032903003703002009" - "41086a200341086a290300370300200941106a200341106a2903003703000c010b" - "200f422088a7ad4220862009ad84210f0240024002400240024020052f01920322" - "09410b490d00200441086a21084104210d200c4105490d03200c210d200c417b6a" - "0e020302010b2005418c026a220e200c410c6c6a210d02400240200c41016a2206" - "20094d0d00200d200f370204200d200b3602000c010b200e2006410c6c6a200d20" - "09200c6b220e410c6c10de808080001a200d200f370204200d200b360200200520" - "0641186c6a2005200c41186c6a200e41186c10de808080001a0b2005200c41186c" - "6a220d41106a200341106a290300370300200d2003290300370300200d41086a20" - "0341086a2903003703002005200941016a3b0192030c030b200c41796a210c2004" - "41f8006a21084106210d0c010b4100210c200441f8006a21084105210d0b41002d" - "00c0cfc080001a4198031084808080002209450d02200941003b01920320094100" - "360288022009200d417f7320052f01920322076a22063b01920320044188016a41" - "086a2005200d41186c6a220e41086a29030037030020044188016a41106a200e41" - "106a2903003703002004200e290300370388012006410c4f0d032007200d41016a" - "220e6b2006470d042005418c026a2202200d410c6c6a2207290204211020072802" - "0021072009418c026a2002200e410c6c6a2006410c6c10df808080001a20092005" - "200e41186c6a200641186c10df8080800021062005200d3b019203200441dc006a" - "410c6a20044190016a290300370200200441f0006a20044198016a290300370200" - "200420042903880137026020042005360208200420063602782008280200220d41" - "8c026a200c410c6c6a210602400240200d2f019203220e200c4b0d002006200f37" - "02042006200b3602000c010b2006410c6a2006200e200c6b2208410c6c10de8080" - "80001a2006200f3702042006200b360200200d200c41186c6a220b41186a200b20" - "0841186c10de808080001a0b200d200c41186c6a220b41106a200341106a290300" - "370300200b2003290300370300200b41086a200341086a290300370300200d200e" - "41016a3b0192032007418080808078460d00200441c4006a200441dc006a41086a" - "290200370200200441cc006a200441dc006a41106a290200370200200441306a41" - "246a200441dc006a41186a28020036020020042010370234200420073602302004" - "200429025c37023c024002400240200528028802220b0d004100210c0c010b2004" - "41306a4104722108200441b8016a210220044188016a4104722107200441b0016a" - "2103200441c0006a210e4100210c4100210603402006200c470d0820052f019003" - "210d200b2f019203410b490d02200641016a210602400240024002400240024002" - "40200d4105490d00200d417b6a0e020203010b2004410436028001200420063602" - "7c2004200b3602782003210b0c040b20044106360280012004200636027c200420" - "0b360278200d41796a210d0c020b20044105360280012004200636027c2004200b" - "36027820044188016a200441f8006a10c18080800020042802b001410520044130" - "6a200e200910c080808000200428028801210d200441086a2007412410df808080" - "001a0c030b20044105360280012004200636027c2004200b3602784100210d0b20" - "02210b0b20044188016a200441f8006a10c180808000200b280200200d20044130" - "6a200e200910c080808000200428028801210d200441086a2007412410df808080" - "001a0b20042802bc01210c20042802b801210920042802b401210620042802b001" - "2105200d418080808078460d032004200d3602302008200441086a412410df8080" - "80001a200528028802220b0d000b0b2001280200220b450d0741002d00c0cfc080" - "001a2001280204210641c803108480808000220d450d03200d200b36029803200d" - "41003b019203200d410036028802200b41003b019003200b200d36028802200120" - "0641016a3602042001200d3602002006200c470d08200d200429033037028c0220" - "0d41013b019203200d2004290340370300200d200936029c03200d4194026a2004" - "41306a41086a280200360200200d41086a200441c8006a290300370300200d4110" - "6a200441d0006a2903003703002009200d36028802200941013b0190030c010b20" - "0b200d200441306a200e200910c0808080000b2001200128020841016a3602080b" - "200041063a00000c070b000b2006410b41c89fc0800010b180808000000b41909f" - "c08000412841b89fc0800010a680808000000b41e89fc08000413541a0a0c08000" - "10a680808000000b41e49dc0800010a280808000000b41cf9ec08000413041809f" - "c0800010a680808000000b20002005200c41186c6a220929030037030020004110" - "6a200941106a220d290300370300200041086a200941086a220b29030037030020" - "092003290300370300200b200341086a290300370300200d200341106a29030037" - "03000b200441c0016a2480808080000be30501067f23808080800041306b220124" - "80808080004100210241002103024020002802002204450d002001200436021820" - "014100360214200120043602082001410036020420012000280204220336021c20" - "01200336020c20002802082103410121020b200120033602202001200236021020" - "01200236020002400240024003400240024002400240024020030d002001280200" - "450d0820012802082104200128020422030d0141002100200128020c2203450d06" - "034020042802980321042003417f6a22030d000c070b0b20012003417f6a360220" - "024020024101712203450d0020012802040d0020012802082103200128020c2200" - "450d03034020032802980321032000417f6a22000d000c040b0b2003450d012001" - "28020421030c030b200421000c050b41f8bac0800010a280808000000b20014200" - "3702082001200336020441012102200141013602000b2001280208210002402001" - "28020c220520032f019203490d0002400340200141246a2003200010bf80808000" - "20012802242203450d0120012802282100200128022c220520032f019203490d02" - "0c000b0b41b0a0c0800010a280808000000b200541016a21040240024020000d00" - "2001200436020c20014100360208200120033602040c010b200320044102746a41" - "98036a21040340200428020022064198036a21042000417f6a22000d000b200142" - "00370208200120063602042003450d040b024020032005410c6c6a418c026a2200" - "2802002204450d00200028020420041082808080000b0240024002400240200320" - "0541186c6a22032d00000e050303030102000b200341046a109b808080000c020b" - "20032802042200450d01200328020820001082808080000c010b200341046a1091" - "8080800020032802042200450d002003280208200041186c1082808080000b2001" - "28022021030c000b0b200421030b0340200141246a2003200010bf808080002001" - "2802242203450d01200128022821000c000b0b200141306a2480808080000b8905" - "03037f017e037f23808080800041f0006b22022480808080004100210302402000" - "2d0000220420012d0000470d00410121030240024002400240024020040e060500" - "01020304050b20002d000120012d00014621030c040b4100210320002903082205" - "2001290308520d030240024002402005a70e03000102000b200029031020012903" - "105121030c050b200029031020012903105121030c040b20002b031020012b0310" - "6121030c030b41002103200028020c2204200128020c470d022000280208200128" - "0208200410dc808080004521030c020b41002103200028020c2206200128020c47" - "0d012001280208210420002802082100200641016a210103402001417f6a220145" - "21032001450d0220002004109c808080002106200441186a2104200041186a2100" - "20060d000c020b0b41002103200028020c2204200128020c470d00200241003602" - "6c2002420037026420024100360254200241003602442002410036023020024100" - "36022020022001280208220636025c200220012802042203360258200220063602" - "4c2002200336024820022000280208220636023820022000280204220136023420" - "0220063602282002200136022420022004410020031b3602602002200341004722" - "033602502002200336024020022004410020011b36023c20022001410047220336" - "022c2002200336021c200241c0006a21070340200241106a2002411c6a109d8080" - "80004101210320022802102201450d0120022802142104200241086a2007109d80" - "80800020022802082200450d0141002103200128020822062000280208470d0120" - "0228020c210820012802042000280204200610dc808080000d0120042008109c80" - "8080000d000b0b200241f0006a24808080800020030bed0201057f024002400240" - "200128022022020d00410021020c010b20012002417f6a36022002400240024020" - "012802004101470d0020012802040d01200128020821030240200128020c220245" - "0d00034020032802980321032002417f6a22020d000b0b20014200370208200120" - "03360204200141013602000c020b4198bbc0800010a280808000000b2001280204" - "21030b2001280208210202400240200128020c220420032f0192034f0d00200321" - "050c010b03402003280288022205450d03200241016a210220032f019003210420" - "052103200420052f0192034f0d000b0b200441016a21030240024020020d002005" - "21060c010b200520034102746a4198036a21030340200328020022064198036a21" - "032002417f6a22020d000b410021030b2001200336020c20014100360208200120" - "063602042005200441186c6a210320052004410c6c6a418c026a21020b20002003" - "360204200020023602000f0b4188bbc0800010a280808000000b4901017f410021" - "010240024020004100480d00024020000d00410121010c020b41002d00c0cfc080" - "001a200010848080800022010d01410121010b20012000109580808000000b2001" - "0b9b0301037f23808080800041d0006b2204248080808000200441386a20002001" - "108080808000024002400240024020042d00384106460d00200441086a41106a20" - "0441386a41106a2205290300370300200441086a41086a200441386a41086a2206" - "29030037030020042004290338370308200441386a200220031080808080002004" - "2d00384106460d01200441206a41106a2005290300370300200441206a41086a20" - "0629030037030020042004290338370320200441086a10a0808080002205450d02" - "200441206a10a0808080002206450d0320052006109c808080002105200441206a" - "108580808000200441086a10858080800002402003450d00200220031082808080" - "000b02402001450d00200020011082808080000b200441d0006a24808080800020" - "050f0b2004200428023c360220419080c08000412b200441206a418080c0800041" - "d080c0800010a180808000000b2004200428023c360220419080c08000412b2004" - "41206a418080c0800041e080c0800010a180808000000b41f880c0800010a28080" - "8000000b418881c0800010a280808000000bea0101077f41002101024020002d00" - "004105470d0020002802042202450d002000280208210303402002418c026a2100" - "20022f0192032204410c6c2105417f2106024002400340024020050d0020042106" - "0c020b2000280208210120002802042107200641016a2106200541746a21052000" - "410c6a2100417f41f080c0800020072001410720014107491b10dc808080002207" - "410720016b20071b220141004720014100481b22014101460d000b200141ff0171" - "450d010b024020030d0041000f0b2003417f6a2103200220064102746a4198036a" - "28020021020c010b0b2002200641186c6a21010b20010b8f0101017f2380808080" - "0041c0006b22052480808080002005200136020c20052000360208200520033602" - "14200520023602102005410236021c200541dc82c0800036021820054202370224" - "2005418180808000ad422086200541106aad843703382005418280808000ad4220" - "86200541086aad843703302005200541306a360220200541186a200410a4808080" - "00000b130041ea81c08000412b200010a680808000000b4701017f238080808000" - "41206b2200248080808000200041003602182000410136020c200041ac81c08000" - "36020820004204370210200041086a41c881c0800010a480808000000b5601017f" - "23808080800041206b2202248080808000200241106a200041106a290200370300" - "200241086a200041086a290200370300200241013b011c20022001360218200220" - "00290200370300200210ae80808000000bbe0601057f200041786a22012000417c" - "6a280200220241787122006a21030240024020024101710d002002410271450d01" - "2001280200220220006a21000240200120026b220141002802f4d2c08000470d00" - "20032802044103714103470d01410020003602ecd2c0800020032003280204417e" - "7136020420012000410172360204200320003602000f0b2001200210a880808000" - "0b024002400240024002400240200328020422024102710d00200341002802f8d2" - "c08000460d02200341002802f4d2c08000460d0320032002417871220210a88080" - "80002001200220006a2200410172360204200120006a2000360200200141002802" - "f4d2c08000470d01410020003602ecd2c080000f0b20032002417e713602042001" - "2000410172360204200120006a20003602000b2000418002490d022001200010d7" - "80808000410021014100410028028cd3c08000417f6a220036028cd3c080002000" - "0d04024041002802d4d0c080002200450d00410021010340200141016a21012000" - "28020822000d000b0b4100200141ff1f200141ff1f4b1b36028cd3c080000f0b41" - "0020013602f8d2c08000410041002802f0d2c0800020006a22003602f0d2c08000" - "200120004101723602040240200141002802f4d2c08000470d00410041003602ec" - "d2c08000410041003602f4d2c080000b20004100280284d3c0800022044d0d0341" - "002802f8d2c080002200450d034100210241002802f0d2c0800022054129490d02" - "41ccd0c080002101034002402001280200220320004b0d00200020032001280204" - "6a490d040b200128020821010c000b0b410020013602f4d2c08000410041002802" - "ecd2c0800020006a22003602ecd2c0800020012000410172360204200120006a20" - "003602000f0b200041f8017141dcd0c080006a21030240024041002802e4d2c080" - "00220241012000410376742200710d00410020022000723602e4d2c08000200321" - "000c010b200328020821000b200320013602082000200136020c2001200336020c" - "200120003602080f0b024041002802d4d0c080002201450d004100210203402002" - "41016a2102200128020822010d000b0b4100200241ff1f200241ff1f4b1b36028c" - "d3c08000200520044d0d004100417f360284d3c080000b0b4d01017f2380808080" - "0041206b2203248080808000200341003602102003410136020420034204370208" - "2003200136021c200320003602182003200341186a3602002003200210a4808080" - "00000b840601057f0240024002402000417c6a2203280200220441787122054104" - "4108200441037122061b20016a490d0002402006450d002005200141276a4b0d02" - "0b41102002410b6a4178712002410b491b210102400240024020060d0020014180" - "02490d0120052001410472490d01200520016b418180084f0d010c020b20004178" - "6a220720056a21060240024002400240200520014f0d00200641002802f8d2c080" - "00460d03200641002802f4d2c08000460d02200628020422044102710d04200441" - "7871220420056a22052001490d042006200410a880808000200520016b22024110" - "490d0120032001200328020041017172410272360200200720016a220120024103" - "72360204200720056a220520052802044101723602042001200210a98080800020" - "000f0b200520016b2202410f4d0d04200320012004410171724102723602002007" - "20016a22052002410372360204200620062802044101723602042005200210a980" - "80800020000f0b20032005200328020041017172410272360200200720056a2202" - "200228020441017236020420000f0b41002802ecd2c0800020056a22052001490d" - "0102400240200520016b2202410f4b0d0020032004410171200572410272360200" - "200720056a2202200228020441017236020441002102410021010c010b20032001" - "200441017172410272360200200720016a22012002410172360204200720056a22" - "05200236020020052005280204417e713602040b410020013602f4d2c080004100" - "20023602ecd2c0800020000f0b41002802f0d2c0800020056a220520014b0d040b" - "0240200210848080800022050d0041000f0b20052000417c417820032802002201" - "4103711b20014178716a2201200220012002491b10df808080002102200010a580" - "808000200221000b20000f0b41c9c5c08000412e41f8c5c0800010a68080800000" - "0b4188c6c08000412e41b8c6c0800010a680808000000b20032001200441017172" - "410272360200200720016a2202200520016b2205410172360204410020053602f0" - "d2c08000410020023602f8d2c0800020000b820301047f200028020c2102024002" - "4002402001418002490d002000280218210302400240024020022000470d002000" - "41144110200028021422021b6a28020022010d01410021020c020b200028020822" - "01200236020c200220013602080c010b200041146a200041106a20021b21040340" - "200421052001220241146a200241106a200228021422011b210420024114411020" - "011b6a28020022010d000b200541003602000b2003450d020240200028021c4102" - "7441cccfc080006a22012802002000460d0020034110411420032802102000461b" - "6a20023602002002450d030c020b2001200236020020020d01410041002802e8d2" - "c08000417e200028021c77713602e8d2c080000c020b0240200220002802082204" - "460d002004200236020c200220043602080f0b410041002802e4d2c08000417e20" - "0141037677713602e4d2c080000f0b20022003360218024020002802102201450d" - "0020022001360210200120023602180b20002802142201450d0020022001360214" - "200120023602180f0b0ba00401027f200020016a21020240024020002802042203" - "4101710d002003410271450d012000280200220320016a21010240200020036b22" - "0041002802f4d2c08000470d0020022802044103714103470d01410020013602ec" - "d2c0800020022002280204417e7136020420002001410172360204200220013602" - "000c020b2000200310a8808080000b024002400240024020022802042203410271" - "0d00200241002802f8d2c08000460d02200241002802f4d2c08000460d03200220" - "03417871220310a8808080002000200320016a2201410172360204200020016a20" - "01360200200041002802f4d2c08000470d01410020013602ecd2c080000f0b2002" - "2003417e7136020420002001410172360204200020016a20013602000b02402001" - "418002490d002000200110d7808080000f0b200141f8017141dcd0c080006a2102" - "0240024041002802e4d2c08000220341012001410376742201710d004100200320" - "01723602e4d2c08000200221010c010b200228020821010b200220003602082001" - "200036020c2000200236020c200020013602080f0b410020003602f8d2c0800041" - "0041002802f0d2c0800020016a22013602f0d2c080002000200141017236020420" - "0041002802f4d2c08000470d01410041003602ecd2c08000410041003602f4d2c0" - "80000f0b410020003602f4d2c08000410041002802ecd2c0800020016a22013602" - "ecd2c0800020002001410172360204200020016a20013602000f0b0b7902017f01" - "7e23808080800041306b2203248080808000200320003602002003200136020420" - "03410236020c200341c485c08000360208200342023702142003418380808000ad" - "4220862204200341046aad84370328200320042003ad843703202003200341206a" - "360210200341086a200210a480808000000b110020003502004101200110ad8080" - "80000b7902017f017e23808080800041306b220324808080800020032001360204" - "200320003602002003410236020c200341c882c080003602082003420237021420" - "03418380808000ad42208622042003ad8437032820032004200341046aad843703" - "202003200341206a360210200341086a200210a480808000000bec0203027f017e" - "037f23808080800041306b2203248080808000412721040240024020004290ce00" - "5a0d00200021050c010b412721040340200341096a20046a2206417c6a20004290" - "ce0080220542f0b1037e20007ca7220741ffff037141e4006e2208410174419283" - "c080006a2f00003b00002006417e6a2008419c7f6c20076a41ffff037141017441" - "9283c080006a2f00003b00002004417c6a2104200042ffc1d72f56210620052100" - "20060d000b0b02400240200542e300560d002005a721060c010b200341096a2004" - "417e6a22046a2005a7220741ffff037141e4006e2206419c7f6c20076a41ffff03" - "71410174419283c080006a2f00003b00000b024002402006410a490d0020034109" - "6a2004417e6a22046a2006410174419283c080006a2f00003b00000c010b200341" - "096a2004417f6a22046a20064130723a00000b2002200141014100200341096a20" - "046a412720046b10af808080002104200341306a24808080800020040b5d01027f" - "23808080800041206b220124808080800020002802182102200141106a20004110" - "6a290200370300200141086a200041086a2902003703002001200036021c200120" - "0236021820012000290200370300200110d880808000000bcb0501077f02400240" - "20010d00200541016a2106200028021c2107412d21080c010b412b418080c40020" - "0028021c220741017122011b2108200120056a21060b0240024020074104710d00" - "410021020c010b0240024020030d00410021090c010b02402003410371220a0d00" - "0c010b41002109200221010340200920012c000041bf7f4a6a2109200141016a21" - "01200a417f6a220a0d000b0b200920066a21060b024020002802000d0002402000" - "28021422012000280218220920082002200310b080808000450d0041010f0b2001" - "20042005200928020c11818080800080808080000f0b0240024002400240200028" - "0204220120064b0d00200028021422012000280218220920082002200310b08080" - "8000450d0141010f0b2007410871450d0120002802102107200041303602102000" - "2d0020210b4101210c200041013a0020200028021422092000280218220a200820" - "02200310b0808080000d02200120066b41016a2101024003402001417f6a220145" - "0d0120094130200a2802101182808080008080808000450d000b41010f0b024020" - "0920042005200a28020c1181808080008080808000450d0041010f0b2000200b3a" - "00202000200736021041000f0b200120042005200928020c118180808000808080" - "8000210c0c010b200120066b210702400240024020002d002022010e0402000100" - "020b20072101410021070c010b20074101762101200741016a41017621070b2001" - "41016a210120002802102106200028021821092000280214210a02400340200141" - "7f6a2201450d01200a200620092802101182808080008080808000450d000b4101" - "0f0b4101210c200a200920082002200310b0808080000d00200a20042005200928" - "020c11818080800080808080000d00410021010340024020072001470d00200720" - "07490f0b200141016a2101200a200620092802101182808080008080808000450d" - "000b2001417f6a2007490f0b200c0b490002402002418080c400460d0020002002" - "20012802101182808080008080808000450d0041010f0b024020030d0041000f0b" - "200020032004200128020c11818080800080808080000b7902017f017e23808080" - "800041306b22032480808080002003200036020020032001360204200341023602" - "0c200341e485c08000360208200342023702142003418380808000ad4220862204" - "200341046aad84370328200320042003ad843703202003200341206a3602102003" - "41086a200210a480808000000bc20b010b7f200028020821030240024002400240" - "200028020022040d002003410171450d010b02402003410171450d00200120026a" - "210502400240200028020c22060d0041002107200121080c010b41002107410021" - "09200121080340200822032005460d020240024020032c00002208417f4c0d0020" - "0341016a21080c010b0240200841604f0d00200341026a21080c010b0240200841" - "704f0d00200341036a21080c010b200341046a21080b200820036b20076a210720" - "06200941016a2209470d000b0b20082005460d00024020082c00002203417f4a0d" - "0020034160491a0b024002402007450d000240200720024f0d00200120076a2c00" - "0041bf7f4a0d01410021030c020b20072002460d00410021030c010b200121030b" - "2007200220031b21022003200120031b21010b024020040d002000280214200120" - "02200028021828020c11818080800080808080000f0b2000280204210a02402002" - "4110490d0020022001200141036a417c7122076b22096a220b4103712104410021" - "0641002103024020012007460d004100210302402009417c4b0d00410021034100" - "210503402003200120056a22082c000041bf7f4a6a200841016a2c000041bf7f4a" - "6a200841026a2c000041bf7f4a6a200841036a2c000041bf7f4a6a210320054104" - "6a22050d000b0b200121080340200320082c000041bf7f4a6a2103200841016a21" - "08200941016a22090d000b0b02402004450d002007200b417c716a22082c000041" - "bf7f4a210620044101460d00200620082c000141bf7f4a6a210620044102460d00" - "200620082c000241bf7f4a6a21060b200b4102762105200620036a210603402007" - "21042005450d04200541c001200541c001491b220b410371210c200b410274210d" - "41002108024020054104490d002004200d41f007716a2109410021082004210303" - "40200328020c2207417f7341077620074106767241818284087120032802082207" - "417f7341077620074106767241818284087120032802042207417f734107762007" - "4106767241818284087120032802002207417f7341077620074106767241818284" - "087120086a6a6a6a2108200341106a22032009470d000b0b2005200b6b21052004" - "200d6a2107200841087641ff81fc0771200841ff81fc07716a418180046c411076" - "20066a2106200c450d000b2004200b41fc01714102746a22082802002203417f73" - "4107762003410676724181828408712103200c4101460d0220082802042207417f" - "7341077620074106767241818284087120036a2103200c4102460d022008280208" - "2208417f7341077620084106767241818284087120036a21030c020b024020020d" - "00410021060c030b2002410371210802400240200241044f0d0041002106410021" - "090c010b41002106200121032002410c71220921070340200620032c000041bf7f" - "4a6a200341016a2c000041bf7f4a6a200341026a2c000041bf7f4a6a200341036a" - "2c000041bf7f4a6a2106200341046a21032007417c6a22070d000b0b2008450d02" - "200120096a21030340200620032c000041bf7f4a6a2106200341016a2103200841" - "7f6a22080d000c030b0b200028021420012002200028021828020c118180808000" - "80808080000f0b200341087641ff811c71200341ff81fc07716a418180046c4110" - "7620066a21060b02400240200a20064d0d00200a20066b21054100210302400240" - "024020002d00200e0402000102020b20052103410021050c010b20054101762103" - "200541016a41017621050b200341016a2103200028021021092000280218210820" - "00280214210703402003417f6a2203450d02200720092008280210118280808000" - "8080808000450d000b41010f0b200028021420012002200028021828020c118180" - "80800080808080000f0b0240200720012002200828020c11818080800080808080" - "00450d0041010f0b410021030340024020052003470d0020052005490f0b200341" - "016a21032007200920082802101182808080008080808000450d000b2003417f6a" - "2005490b140020012000280200200028020410b2808080000b1c00200028020020" - "01200028020428020c11828080800080808080000bbf05010a7f23808080800041" - "306b2203248080808000200341033a002c2003412036021c410021042003410036" - "02282003200136022420032000360220200341003602142003410036020c024002" - "40024002400240200228021022050d00200228020c2200450d0120022802082101" - "200041037421062000417f6a41ffffffff017141016a2104200228020021000340" - "0240200041046a2802002207450d00200328022020002802002007200328022428" - "020c11818080800080808080000d040b20012802002003410c6a20012802041182" - "8080800080808080000d03200141086a2101200041086a2100200641786a22060d" - "000c020b0b20022802142201450d00200141057421082001417f6a41ffffff3f71" - "41016a210420022802082109200228020021004100210603400240200041046a28" - "02002201450d00200328022020002802002001200328022428020c118180808000" - "80808080000d030b2003200520066a220141106a28020036021c20032001411c6a" - "2d00003a002c2003200141186a2802003602282001410c6a28020021074100210a" - "4100210b024002400240200141086a2802000e03010002010b2007410374210c41" - "00210b2009200c6a220c2802040d01200c28020021070b4101210b0b2003200736" - "02102003200b36020c200141046a280200210702400240024020012802000e0301" - "0002010b2007410374210b2009200b6a220b2802040d01200b28020021070b4101" - "210a0b200320073602182003200a3602142009200141146a2802004103746a2201" - "2802002003410c6a200128020411828080800080808080000d02200041086a2100" - "2008200641206a2206470d000b0b200420022802044f0d01200328022020022802" - "0020044103746a22012802002001280204200328022428020c1181808080008080" - "808000450d010b410121010c010b410021010b200341306a24808080800020010b" - "d70201057f2380808080004180016b220224808080800002400240024002402001" - "28021c22034110710d0020034120710d012000ad4101200110ad8080800021000c" - "030b41ff00210303402002200322046a22052000410f712203413072200341d700" - "6a2003410a491b3a00002004417f6a210320004110492106200041047621002006" - "450d000c020b0b41ff00210303402002200322046a22052000410f712203413072" - "200341376a2003410a491b3a00002004417f6a2103200041104921062000410476" - "21002006450d000b02402004418101490d002004418001418083c0800010aa8080" - "8000000b20014101419083c0800041022005418101200441016a6b10af80808000" - "21000c010b02402004418101490d002004418001418083c0800010aa8080800000" - "0b20014101419083c0800041022005418101200441016a6b10af8080800021000b" - "20024180016a24808080800020000b7902017f017e23808080800041306b220324" - "808080800020032000360200200320013602042003410236020c2003419886c080" - "00360208200342023702142003418380808000ad4220862204200341046aad8437" - "0328200320042003ad843703202003200341206a360210200341086a200210a480" - "808000000b920c01057f23808080800041206b2203248080808000024002400240" - "024002400240024002400240024002400240024002400240024020010e28060101" - "010101010101020401010301010101010101010101010101010101010101010901" - "01010107000b200141dc00460d040b2001418006490d0b20024101710d060c0b0b" - "20004180043b010a20004200370102200041dce8013b01000c0c0b20004180043b" - "010a20004200370102200041dce4013b01000c0b0b20004180043b010a20004200" - "370102200041dcdc013b01000c0a0b20004180043b010a20004200370102200041" - "dcb8013b01000c090b20004180043b010a20004200370102200041dce0003b0100" - "0c080b200241800271450d0620004180043b010a20004200370102200041dcce00" - "3b01000c070b200141aa9d044b410474220220024108722202200241027441a896" - "c080006a280200410b742001410b7422024b1b2204200441047222042004410274" - "41a896c080006a280200410b7420024b1b220420044102722204200441027441a8" - "96c080006a280200410b7420024b1b2204200441016a2204200441027441a896c0" - "80006a280200410b7420024b1b2204200441016a2204200441027441a896c08000" - "6a280200410b7420024b1b220441027441a896c080006a280200410b7422052002" - "4620052002496a20046a220441204b0d01200441027441a896c080006a22052802" - "00411576210241d70521060240024020044120460d002005280204411576210620" - "040d00410021040c010b200441027441a496c080006a28020041ffffff00712104" - "0b024020062002417f736a450d00200120046b2107200241d705200241d7054b1b" - "21052006417f6a210641002104034020052002460d042004200241ac97c080006a" - "2d00006a220420074b0d012006200241016a2202470d000b200621020b20024101" - "71450d04200341003a000a200341003b01082003200141147641da81c080006a2d" - "00003a000b20032001410476410f7141da81c080006a2d00003a000f2003200141" - "0876410f7141da81c080006a2d00003a000e20032001410c76410f7141da81c080" - "006a2d00003a000d20032001411076410f7141da81c080006a2d00003a000c2003" - "41086a20014101726741027622026a220441fb003a00002004417f6a41f5003a00" - "00200341086a2002417e6a22026a41dc003a0000200341086a41086a2204200141" - "0f7141da81c080006a2d00003a00002000410a3a000b200020023a000a20002003" - "290208370200200341fd003a0011200041086a20042f01003b01000c060b200241" - "808004710d020c040b20044121418896c0800010ac80808000000b200541d70541" - "9896c0800010ac80808000000b20004180043b010a20004200370102200041dcc4" - "003b01000c020b024020014120490d00200141ff00490d01024020014180800449" - "0d0002402001418080084f0d00200141ec8ac08000412c41c48bc0800041c40141" - "888dc0800041c20310b980808000450d020c030b200141feffff0071419ef00a46" - "0d01200141e0ffff007141e0cd0a460d01200141c091756a41794b0d01200141d0" - "e2746a41714b0d0120014190a8746a41704b0d012001418090746a41dd6c4b0d01" - "2001418080746a419d744b0d01200141b0d9736a417a4b0d0120014180fe476a41" - "afc5544b0d01200141f083384f0d010c020b200141ca90c080004128419a91c080" - "0041a00241ba93c0800041ad0210b9808080000d010b200341003a001620034100" - "3b01142003200141147641da81c080006a2d00003a001720032001410476410f71" - "41da81c080006a2d00003a001b20032001410876410f7141da81c080006a2d0000" - "3a001a20032001410c76410f7141da81c080006a2d00003a001920032001411076" - "410f7141da81c080006a2d00003a0018200341146a20014101726741027622026a" - "220441fb003a00002004417f6a41f5003a0000200341146a2002417e6a22026a41" - "dc003a0000200341146a41086a22042001410f7141da81c080006a2d00003a0000" - "2000410a3a000b200020023a000a20002003290214370200200341fd003a001d20" - "0041086a20042f01003b01000c010b2000200136020420004180013a00000b2003" - "41206a2480808080000be90201067f200120024101746a210720004180fe037141" - "0876210841002109200041ff0171210a02400240024002400340200141026a210b" - "200920012d000122026a210c024020012d000022012008460d00200120084b0d04" - "200c2109200b2101200b2007470d010c040b200c2009490d01200c20044b0d0220" - "0320096a21010340024020020d00200c2109200b2101200b2007470d020c050b20" - "02417f6a210220012d00002109200141016a21012009200a470d000b0b41002102" - "0c030b2009200c41dc8ac0800010b780808000000b200c200441dc8ac0800010b1" - "80808000000b200041ffff03712109200520066a210c410121020340200541016a" - "210a0240024020052c000022014100480d00200a21050c010b0240200a200c460d" - "00200141ff007141087420052d0001722101200541026a21050c010b41cc8ac080" - "0010a280808000000b200920016b22094100480d01200241017321022005200c47" - "0d000b0b20024101710b13002000200120022003200410bb80808000000bd10902" - "057f017e23808080800041f0006b22052480808080002005200336020c20052002" - "3602080240024002400240024002400240024002402001418102490d0002402000" - "2c00800241bf7f4c0d00410321060c030b20002c00ff0141bf7f4c0d0141022106" - "0c020b200520013602142005200036021041002106410121070c020b20002c00fe" - "0141bf7f4a21060b2000200641fd016a22066a2c000041bf7f4c0d012005200636" - "0214200520003602104105210641a888c0800021070b2005200636021c20052007" - "3602180240200220014b22060d00200320014b0d00200220034b0d020240200245" - "0d00200220014f0d0020032002200020026a2c000041bf7f4a1b21030b20052003" - "360220200121020240200320014f0d00200341016a220641002003417d6a220220" - "0220034b1b2202490d04024020062002460d00200620026b21080240200020036a" - "2c000041bf7f4c0d002008417f6a21070c010b20022003460d000240200020066a" - "2206417e6a22032c000041bf7f4c0d002008417e6a21070c010b200020026a2209" - "2003460d0002402006417d6a22032c000041bf7f4c0d002008417d6a21070c010b" - "20092003460d0002402006417c6a22032c000041bf7f4c0d002008417c6a21070c" - "010b20092003460d002008417b6a21070b200720026a21020b02402002450d0002" - "40200220014f0d00200020026a2c000041bf7f4a0d010c070b20022001470d060b" - "20022001460d040240024002400240200020026a22032c00002201417f4a0d0020" - "032d0001413f7121002001411f7121062001415f4b0d0120064106742000722101" - "0c020b2005200141ff0171360224410121010c020b200041067420032d0002413f" - "717221000240200141704f0d0020002006410c747221010c010b20004106742003" - "2d0003413f71722006411274418080f00071722201418080c400460d060b200520" - "01360224024020014180014f0d00410121010c010b024020014180104f0d004102" - "21010c010b41034104200141808004491b21010b20052002360228200520012002" - "6a36022c20054105360234200541b089c080003602302005420537023c20054182" - "80808000ad422086220a200541186aad843703682005200a200541106aad843703" - "602005418480808000ad422086200541286aad843703582005418580808000ad42" - "2086200541246aad843703502005418380808000ad422086200541206aad843703" - "482005200541c8006a360238200541306a200410a480808000000b200520022003" - "20061b36022820054103360234200541f089c080003602302005420337023c2005" - "418280808000ad422086220a200541186aad843703582005200a200541106aad84" - "3703502005418380808000ad422086200541286aad843703482005200541c8006a" - "360238200541306a200410a480808000000b2000200141002006200410ba808080" - "00000b20054104360234200541d088c080003602302005420437023c2005418280" - "808000ad422086220a200541186aad843703602005200a200541106aad84370358" - "2005418380808000ad422086220a2005410c6aad843703502005200a200541086a" - "ad843703482005200541c8006a360238200541306a200410a480808000000b2002" - "2006419c8ac0800010b780808000000b200410a280808000000b20002001200220" - "01200410ba80808000000b4d01017f4101210202402000280200200110b6808080" - "000d00200128021441d881c080004102200128021828020c118180808000808080" - "80000d002000280204200110b68080800021020b20020bc40101047f2380808080" - "0041106b2202248080808000410121030240200128021422044127200128021822" - "05280210220111828080800080808080000d00200241046a200028020041810210" - "b8808080000240024020022d0004418001470d0020042002280208200111828080" - "80008080808000450d010c020b2004200241046a20022d000e22006a20022d000f" - "20006b200528020c11818080800080808080000d010b2004412720011182808080" - "00808080800021030b200241106a24808080800020030b2701017f200028020022" - "002000411f7522027320026bad2000417f73411f76200110ad808080000b500103" - "7f200121032002210402402001280288022205450d00200241016a210320012f01" - "900321040b200141c80341980320021b1082808080002000200536020020002004" - "ad4220862003ad843702040bec0201047f2000418c026a22052001410c6c6a2106" - "02400240200141016a220720002f01920322084d0d002006200229020037020020" - "0641086a200241086a2802003602000c010b20052007410c6c6a2006200820016b" - "2205410c6c10de808080001a200641086a200241086a2802003602002006200229" - "02003702002000200741186c6a2000200141186c6a200541186c10de808080001a" - "0b200841016a21022000200141186c6a22062003290300370300200641106a2003" - "41106a290300370300200641086a200341086a29030037030020004198036a2103" - "0240200141026a2205200841026a22064f0d00200320054102746a200320074102" - "746a200820016b41027410de808080001a0b200320074102746a20043602002000" - "20023b0192030240200720064f0d00200841016a2103200141027420006a419c03" - "6a2107034020072802002208200141016a22013b01900320082000360288022007" - "41046a210720032001470d000b0b0bed04010a7f23808080800041d0006b220224" - "808080800041002d00c0cfc080001a200128020022032f01920321040240024002" - "400240024041c8031084808080002205450d002005410036028802200520012802" - "082206417f7320032f01920322076a22083b019203200241286a41086a2003418c" - "026a22092006410c6c6a220a41086a280200360200200241386a41086a20032006" - "41186c6a220b41086a290300370300200241386a41106a200b41106a2903003703" - "002002200a2902003703282002200b2903003703382008410c4f0d012007200641" - "016a220b6b2008470d022005418c026a2009200b410c6c6a2008410c6c10df8080" - "80001a20052003200b41186c6a200841186c10df80808000210b200320063b0192" - "03200241086a200241286a41086a280200360200200241186a200241386a41086a" - "290300370300200241206a200241c8006a29030037030020022002290328370300" - "20022002290338370310200b2f019203220541016a21082005410c4f0d03200420" - "066b220a2008470d04200b4198036a200320064102746a419c036a200a41027410" - "df80808000210a200128020421014100210602400340200a20064102746a280200" - "220820063b0190032008200b36028802200620054f0d01200620062005496a2206" - "20054d0d000b0b2000200136022c2000200336022820002002412810df80808000" - "220620013602342006200b360230200241d0006a2480808080000f0b000b200841" - "0b41c89fc0800010b180808000000b41909fc08000412841b89fc0800010a68080" - "8000000b2008410c41d89fc0800010b180808000000b41909fc08000412841b89f" - "c0800010a680808000000bbb0b01037f2380808080004180016b22022480808080" - "00200028020021002002410036022c2002428080808010370224200241033a0050" - "200241203602402002410036024c200241c0a0c080003602482002410036023820" - "0241003602302002200241246a3602440240024002400240024002400240024002" - "400240024002400240024002400240024002400240024002400240024002400240" - "02400240024020002802000e1918000102030405060708090a0b0c0d0e0f101112" - "1314151617180b024002400240024020002d00040e0400010203000b2002200028" - "020836025441002d00c0cfc080001a41141084808080002203450d1c200341106a" - "41002800f4ccc08000360000200341086a41002900ecccc0800037000020034100" - "2900e4ccc08000370000200241143602602002200336025c200241143602582002" - "410336026c200241ccccc08000360268200242023702742002418680808000ad42" - "2086200241d4006aad843703102002418780808000ad422086200241d8006aad84" - "3703082002200241086a360270200241246a41c0a0c08000200241e8006a10b580" - "8080002103024020022802582204450d00200228025c20041082808080000b2003" - "0d1d0c1b0b20002d000521032002410136026c200241c8c6c08000360268200242" - "013702742002418280808000ad422086200241086aad8437035820022003410274" - "220341f8ccc080006a28020036020c20022003419ccec080006a28020036020820" - "02200241d8006a360270200241246a41c0a0c08000200241e8006a10b580808000" - "0d1c0c1a0b200241306a20002802082203280200200328020410b2808080000d1b" - "0c190b20002802082203280200200241306a200328020428021011828080800080" - "808080000d1a0c180b200241246a4181a2c08000411810c4808080000d190c170b" - "200241246a4199a2c08000411b10c4808080000d180c160b200241246a41b4a2c0" - "8000411a10c4808080000d170c150b200241246a41cea2c08000411910c4808080" - "000d160c140b200241246a41e7a2c08000410c10c4808080000d150c130b200241" - "246a41f3a2c08000411310c4808080000d140c120b200241246a4186a3c0800041" - "1310c4808080000d130c110b200241246a4199a3c08000410e10c4808080000d12" - "0c100b200241246a41a7a3c08000410e10c4808080000d110c0f0b200241246a41" - "b5a3c08000410c10c4808080000d100c0e0b200241246a41c1a3c08000410e10c4" - "808080000d0f0c0d0b200241246a41cfa3c08000410e10c4808080000d0e0c0c0b" - "200241246a41dda3c08000411310c4808080000d0d0c0b0b200241246a41f0a3c0" - "8000411a10c4808080000d0c0c0a0b200241246a418aa4c08000413e10c4808080" - "000d0b0c090b200241246a41c8a4c08000411410c4808080000d0a0c080b200241" - "246a41dca4c08000413410c4808080000d090c070b200241246a4190a5c0800041" - "2c10c4808080000d080c060b200241246a41bca5c08000412410c4808080000d07" - "0c050b200241246a41e0a5c08000410e10c4808080000d060c040b200241246a41" - "eea5c08000411310c4808080000d050c030b200241246a4181a6c08000411c10c4" - "808080000d040c020b200241246a419da6c08000411810c480808000450d010c03" - "0b200241246a2000280204200028020810c4808080000d020b200241d8006a4108" - "6a200241246a41086a280200360200200220022902243703582002418380808000" - "36027c2002418380808000360274200241888080800036026c2002410436020c20" - "0241d0a6c08000360208200242033702142002200041106a36027820022000410c" - "6a3602702002200241d8006a3602682002200241e8006a36021020012802142001" - "280218200241086a10b5808080002100024020022802582201450d00200228025c" - "20011082808080000b20024180016a24808080800020000f0b000b41e8a0c08000" - "4137200241e8006a41d8a0c0800041eca1c0800010a180808000000b1400200120" - "00280204200028020810b2808080000b4b01017f02402000280200200028020822" - "036b20024f0d0020002003200210cf80808000200028020821030b200028020420" - "036a2001200210df808080001a2000200320026a36020841000bd507010d7f2380" - "8080800041106b2202248080808000200028020821032000280204210441012105" - "024020012802142206412220012802182207280210220811828080800080808080" - "000d000240024020030d0041002103410021000c010b410021094100210a200421" - "0b2003210c024002400340200b200c6a210d4100210002400340200b20006a220e" - "2d0000220141817f6a41ff017141a101490d0120014122460d01200141dc00460d" - "01200c200041016a2200470d000b200a200c6a210a0c030b02400240200e2c0000" - "2201417f4c0d00200e41016a210b200141ff017121010c010b200e2d0001413f71" - "210b2001411f71210c02402001415f4b0d00200c410674200b722101200e41026a" - "210b0c010b200b410674200e2d0002413f7172210b0240200141704f0d00200b20" - "0c410c74722101200e41036a210b0c010b200b410674200e2d0003413f7172200c" - "411274418080f00071722101200e41046a210b0b2000200a6a2100200241046a20" - "014181800410b8808080000240024020022d0004418001460d0020022d000f2002" - "2d000e6b41ff01714101460d0020002009490d0302402009450d00024020092003" - "4f0d00200420096a2c000041bf7f4a0d010c050b20092003470d040b0240200045" - "0d000240200020034f0d00200420006a2c000041bf7f4c0d050c010b2000200347" - "0d040b2006200420096a200020096b200728020c220e1181808080008080808000" - "0d010240024020022d0004418001470d0020062002280208200811828080800080" - "80808000450d010c030b2006200241046a20022d000e220c6a20022d000f200c6b" - "200e11818080800080808080000d020b0240024020014180014f0d004101210e0c" - "010b024020014180104f0d004102210e0c010b41034104200141808004491b210e" - "0b200e20006a21090b0240024020014180014f0d00410121010c010b0240200141" - "80104f0d00410221010c010b41034104200141808004491b21010b200120006a21" - "0a200d200b6b220c0d010c030b0b410121050c030b200420032009200041f084c0" - "800010ba80808000000b02402009200a4b0d004100210002402009450d00024020" - "0920034f0d0020092100200420096a2c000041bf7f4c0d020c010b200321002009" - "2003470d010b0240200a0d00410021030c020b0240200a20034f0d002000210920" - "04200a6a2c000041bf7f4c0d01200a21030c020b20002109200a2003460d010b20" - "0420032009200a418085c0800010ba80808000000b2006200420006a200320006b" - "200728020c11818080800080808080000d00200641222008118280808000808080" - "800021050b200241106a24808080800020050b2200200128021441fca1c0800041" - "05200128021828020c11818080800080808080000b1e01017f0240200028020022" - "01450d00200028020420011082808080000b0b5301047f02402000280208220120" - "0028020422024f0d00200028020021030340200320016a2d000022044122460d01" - "200441dc00460d0120044120490d012000200141016a220136020820022001470d" - "000b0b0b4901017f02402000280200200028020822036b20024f0d002000200320" - "0210cf80808000200028020821030b200028020420036a2001200210df80808000" - "1a2000200320026a3602080bb10501077f23808080800041106b22042480808080" - "0002402003450d004100200341796a2205200520034b1b2106200241036a417c71" - "20026b21074100210503400240024002400240200220056a2d00002208c0220941" - "00480d00200720056b4103710d01200520064f0d020340200220056a2208280204" - "200828020072418081828478710d03200541086a22052006490d000c030b0b0240" - "024002400240024002400240200841a886c080006a2d0000417e6a0e0300010205" - "0b200541016a220520034f0d04200220056a2c000041bf7f4a0d040c050b200541" - "016a220a20034f0d032002200a6a2c0000210a02400240200841e001460d002008" - "41ed01460d012009411f6a41ff0171410c490d032009417e71416e470d05200a41" - "40480d040c050b200a41607141a07f460d030c040b200a419f7f4a0d030c020b20" - "0541016a220a20034f0d022002200a6a2c0000210a024002400240024020084190" - "7e6a0e050100000002000b2009410f6a41ff017141024b0d05200a4140480d020c" - "050b200a41f0006a41ff01714130490d010c040b200a418f7f4a0d030b20054102" - "6a220820034f0d02200220086a2c000041bf7f4a0d02200541036a220520034f0d" - "02200220056a2c000041bf7f4c0d030c020b200a41404e0d010b200541026a2205" - "20034f0d00200220056a2c000041bf7f4c0d010b200441086a2001280200200128" - "020420012802081083808080004100210241002d00c0cfc080001a200428020c21" - "0520042802082108024041141084808080002203450d002003200836020c200341" - "0f360200200320053602100c060b000b200541016a21050c020b200541016a2105" - "0c010b200520034f0d000340200220056a2c00004100480d012003200541016a22" - "05470d000c030b0b20052003490d000b0b20002002360200200020033602042004" - "41106a2480808080000b5901017f23808080800041106b22012480808080002001" - "41086a2000200028020041014101410110d4808080000240200128020822004181" - "80808078460d002000200128020c109580808000000b200141106a248080808000" - "0be20601057f23808080800041206b2202248080808000200241146a200010cd80" - "8080000240024020022f01140d0002400240024002400240024020022f01162203" - "4180f803714180b803460d0020034180c8006a41ffff03714180f803490d042002" - "41146a200010ce8080800020022d00140d0620022d001521042000200028020822" - "0541016a360208200441dc00470d03200241146a200010ce8080800020022d0014" - "0d0620022d001521042000200541026a360208200441f500470d02200241146a20" - "0010cd8080800020022f01140d0620022f011622044180c0006a41ffff03714180" - "f803490d0120034180d0006a41ffff0371410a7420044180c8006a41ffff037172" - "2205418080046a210302402001280200200128020822006b41034b0d0020012000" - "410410cf80808000200128020821000b2001200041046a36020820012802042000" - "6a2200200341127641f001723a0000200041036a2004413f71418001723a000020" - "002005410676413f71418001723a000220002003410c76413f71418001723a0001" - "410021000c070b200220002802002000280204200028020810838080800041002d" - "00c0cfc080001a200228020421012002280200210341141084808080002200450d" - "042000200336020c20004114360200200020013602100c060b200241086a200028" - "02002000280204200028020810838080800041002d00c0cfc080001a200228020c" - "21012002280208210341141084808080002200450d032000200336020c20004114" - "360200200020013602100c050b200241173602142000200241146a10d080808000" - "21000c040b200241173602142000200241146a10d08080800021000c030b024002" - "4002402003418001490d0002402001280200200128020822046b41034b0d002001" - "2004410410cf80808000200128020821040b200128020420046a21002003418010" - "4f0d0120034106764140722106410221050c020b02402001280208220020012802" - "00470d00200110cb808080000b2001200041016a360208200128020420006a2003" - "3a0000410021000c040b20002003410676413f71418001723a00012003410c7641" - "60722106410321050b200020063a00002001200420056a360208200020056a417f" - "6a2003413f71418001723a0000410021000c020b000b200228021821000b200241" - "206a24808080800020000b910301057f23808080800041106b2202248080808000" - "02400240024002402001280204220320012802082204490d000240200320046b41" - "034b0d0020012003360208200241086a2001280200200320031083808080004100" - "2d00c0cfc080001a200228020c2103200228020821044114108480808000220145" - "0d022001200436020c2001410436020020002001360204200120033602100c030b" - "2001200441046a220536020802402001280200220620046a22012d000141017441" - "88bdc080006a2f010020012d00004101744188c1c080006a2f010072c141087420" - "012d00024101744188c1c080006a2e01007220012d00034101744188bdc080006a" - "2e0100722201417f4a0d00200220062003200510838080800041002d00c0cfc080" - "001a200228020421032002280200210441141084808080002201450d0220012004" - "36020c2001410c36020020002001360204200120033602100c030b200020013b01" - "02410021010c030b2004200341f8bcc0800010aa808080000b000b410121010b20" - "0020013b0100200241106a2480808080000bb20101037f23808080800041106b22" - "022480808080000240024002402001280208220320012802042204490d00200241" - "086a20012802002004200310838080800041002d00c0cfc080001a200228020c21" - "032002280208210441141084808080002201450d022001200436020c2001410436" - "02002000200136020420012003360210410121010c010b2000200128020020036a" - "2d00003a0001410021010b200020013a0000200241106a2480808080000f0b000b" - "5601017f23808080800041106b2203248080808000200341086a20002001200241" - "01410110d480808000024020032802082202418180808078460d00200220032802" - "0c109580808000000b200341106a2480808080000b8c0101037f23808080800041" - "106b2202248080808000200241086a200028020020002802042000280208108380" - "80800041002d00c0cfc080001a200228020c210320022802082104024041141084" - "8080800022000d00000b2000200436020c20002001290200370200200020033602" - "10200041086a200141086a280200360200200241106a24808080800020000b1f00" - "024020012802040e020000000b20004188c5c08000200110b5808080000be30201" - "027f23808080800041106b22022480808080000240024002400240200141800149" - "0d002002410036020c2001418010490d0102402001418080044f0d002002200141" - "3f71418001723a000e20022001410c7641e001723a000c20022001410676413f71" - "418001723a000d410321010c030b20022001413f71418001723a000f2002200141" - "127641f001723a000c20022001410676413f71418001723a000e20022001410c76" - "413f71418001723a000d410421010c020b0240200028020822032000280200470d" - "00200010cb808080000b2000200341016a360208200028020420036a20013a0000" - "0c020b20022001413f71418001723a000d2002200141067641c001723a000c4102" - "21010b02402000280200200028020822036b20014f0d0020002003200110cf8080" - "8000200028020821030b200028020420036a2002410c6a200110df808080001a20" - "00200320016a3602080b200241106a24808080800041000b820101017f02400240" - "024002402003280204450d000240200328020822040d002002450d0341002d00c0" - "cfc080001a0c020b20032802002004200210a78080800021030c030b2002450d01" - "41002d00c0cfc080001a0b200210848080800021030c010b200121030b20002002" - "36020820002003200120031b36020420002003453602000b9f0202047f017e2380" - "8080800041206b2206248080808000024002400240200220036a220320024f0d00" - "410021020c010b41002102200420056a417f6a410020046b71ad41084104200541" - "01461b22072001280200220841017422092003200920034b1b2203200720034b1b" - "2207ad7e220a422088a70d00200aa7220941808080807820046b4b0d0102400240" - "20080d00410021020c010b2006200820056c36021c200620012802043602142004" - "21020b20062002360218200641086a20042009200641146a10d380808000024020" - "062802080d00200628020c21022001200736020020012002360204418180808078" - "21020c010b20062802102103200628020c21020c010b0b20002003360204200020" - "02360200200641206a2480808080000b0300000b0900200041003602000bc30201" - "047f411f21020240200141ffffff074b0d002001410620014108766722026b7641" - "017120024101746b413e6a21020b200042003702102000200236021c2002410274" - "41cccfc080006a2103024041002802e8d2c0800041012002742204710d00200320" - "00360200200020033602182000200036020c20002000360208410041002802e8d2" - "c080002004723602e8d2c080000f0b024002400240200328020022042802044178" - "712001470d00200421020c010b20014100411920024101766b2002411f461b7421" - "03034020042003411d764104716a41106a22052802002202450d02200341017421" - "032002210420022802044178712001470d000b0b20022802082203200036020c20" - "022000360208200041003602182000200236020c200020033602080f0b20052000" - "360200200020043602182000200036020c200020003602080b0b00200010d98080" - "8000000bb50101037f23808080800041106b2201248080808000200028020c2102" - "024002400240024020002802040e020001020b20020d0141012102410021030c02" - "0b20020d00200028020022022802042103200228020021020c010b200141808080" - "80783602002001200036020c2001418980808000200028021c22002d001c20002d" - "001d10da80808000000b20012003360204200120023602002001418a8080800020" - "0028021c22002d001c20002d001d10da80808000000b990101027f238080808000" - "41106b2204248080808000410041002802c8cfc08000220541016a3602c8cfc080" - "00024020054100480d000240024041002d0094d3c080000d0041004100280290d3" - "c0800041016a360290d3c0800041002802c4cfc08000417f4a0d010c020b200441" - "086a200020011183808080008080808000000b410041003a0094d3c08000200245" - "0d0010d580808000000b000b0c00200020012902003703000b4a01037f41002103" - "02402002450d000240034020002d0000220420012d00002205470d01200041016a" - "2100200141016a21012002417f6a2202450d020c000b0b200420056b21030b2003" - "0bac0501087f0240024002400240200020016b20024f0d00200120026a21032000" - "20026a21040240200241104f0d00200021050c030b2004417c7121054100200441" - "037122066b210702402006450d00200120026a417f6a210803402004417f6a2204" - "20082d00003a00002008417f6a210820052004490d000b0b2005200220066b2209" - "417c7122066b21040240200320076a2207410371450d0020064101480d02200741" - "0374220841187121022007417c71220a417c6a2101410020086b4118712103200a" - "280200210803402005417c6a220520082003742001280200220820027672360200" - "2001417c6a210120042005490d000c030b0b20064101480d01200920016a417c6a" - "210103402005417c6a220520012802003602002001417c6a210120042005490d00" - "0c020b0b02400240200241104f0d00200021040c010b2000410020006b41037122" - "036a210502402003450d0020002104200121080340200420082d00003a00002008" - "41016a2108200441016a22042005490d000b0b2005200220036b2209417c712207" - "6a210402400240200120036a2206410371450d0020074101480d01200641037422" - "0841187121022006417c71220a41046a2101410020086b4118712103200a280200" - "21080340200520082002762001280200220820037472360200200141046a210120" - "0541046a22052004490d000c020b0b20074101480d002006210103402005200128" - "0200360200200141046a2101200541046a22052004490d000b0b20094103712102" - "200620076a21010b2002450d02200420026a21050340200420012d00003a000020" - "0141016a2101200441016a22042005490d000c030b0b20094103712201450d0120" - "07410020066b6a2103200420016b21050b2003417f6a210103402004417f6a2204" - "20012d00003a00002001417f6a210120052004490d000b0b20000b0e0020002001" - "200210dd808080000bc10201087f02400240200241104f0d00200021030c010b20" - "00410020006b41037122046a210502402004450d00200021032001210603402003" - "20062d00003a0000200641016a2106200341016a22032005490d000b0b20052002" - "20046b2207417c7122086a210302400240200120046a2209410371450d00200841" - "01480d012009410374220641187121022009417c71220a41046a2101410020066b" - "4118712104200a2802002106034020052006200276200128020022062004747236" - "0200200141046a2101200541046a22052003490d000c020b0b20084101480d0020" - "092101034020052001280200360200200141046a2101200541046a22052003490d" - "000b0b20074103712102200920086a21010b02402002450d00200320026a210503" - "40200320012d00003a0000200141016a2101200341016a22032005490d000b0b20" - "000b0bca4f0100418080c0000bc04f0b00000004000000040000000c0000006361" - "6c6c65642060526573756c743a3a756e77726170282960206f6e20616e20604572" - "72602076616c7565756c6c727565616c73657372632f6c69622e72730045001000" - "0a000000150000004b000000450010000a000000160000004b0000004163636f75" - "6e7400450010000a0000001700000033000000450010000a000000180000003300" - "00006361706163697479206f766572666c6f770000009800100011000000616c6c" - "6f632f7372632f7261775f7665632e7273b4001000140000001800000005000000" - "2e2e3031323334353637383961626364656663616c6c656420604f7074696f6e3a" - "3a756e77726170282960206f6e206120604e6f6e65602076616c7565696e646578" - "206f7574206f6620626f756e64733a20746865206c656e20697320206275742074" - "686520696e6465782069732000150110002000000035011000120000003a200000" - "01000000000000005801100002000000636f72652f7372632f666d742f6e756d2e" - "7273006c0110001300000066000000170000003078303030313032303330343035" - "303630373038303931303131313231333134313531363137313831393230323132" - "323233323432353236323732383239333033313332333333343335333633373338" - "333934303431343234333434343534363437343834393530353135323533353435" - "353536353735383539363036313632363336343635363636373638363937303731" - "373237333734373537363737373837393830383138323833383438353836383738" - "3838393930393139323933393439353936393739383939636f72652f7372632f66" - "6d742f6d6f642e72730000005a021000130000009b090000260000005a02100013" - "000000a40900001a00000072616e676520737461727420696e64657820206f7574" - "206f662072616e676520666f7220736c696365206f66206c656e67746820900210" - "0012000000a20210002200000072616e676520656e6420696e64657820d4021000" - "10000000a202100022000000736c69636520696e64657820737461727473206174" - "202062757420656e64732061742000f4021000160000000a0310000d0000000101" - "010101010101010101010101010101010101010101010101010101010101010101" - "010101010101010101010101010101010101010101010101010101010101010101" - "010101010101010101010101010101010101010101010101010101010101010101" - "010101010101010101010101010101010101010101010101010101000000000000" - "000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000020202020202" - "020202020202020202020202020202020202020202020202030303030303030303" - "03030303030303040404040400000000000000000000005b2e2e2e5d626567696e" - "203c3d20656e642028203c3d2029207768656e20736c6963696e672060602d0410" - "000e0000003b041000040000003f041000100000004f0410000100000062797465" - "20696e64657820206973206e6f742061206368617220626f756e646172793b2069" - "7420697320696e7369646520202862797465732029206f66206000700410000b00" - "00007b04100026000000a104100008000000a9041000060000004f041000010000" - "00206973206f7574206f6620626f756e6473206f6620600000700410000b000000" - "d8041000160000004f04100001000000636f72652f7372632f7374722f6d6f642e" - "7273000805100013000000f00000002c000000636f72652f7372632f756e69636f" - "64652f7072696e7461626c652e72730000002c0510001d0000001a000000360000" - "002c0510001d0000000a0000002b00000000060101030104020507070208080902" - "0a050b020e041001110212051311140115021702190d1c051d081f0124016a046b" - "02af03b102bc02cf02d102d40cd509d602d702da01e005e102e704e802ee20f004" - "f802fa03fb010c273b3e4e4f8f9e9e9f7b8b9396a2b2ba86b1060709363d3e56f3" - "d0d1041418363756577faaaeafbd35e01287898e9e040d0e11122931343a454649" - "4a4e4f64655cb6b71b1c07080a0b141736393aa8a9d8d909379091a8070a3b3e66" - "698f92116f5fbfeeef5a62f4fcff53549a9b2e2f2728559da0a1a3a4a7a8adbabc" - "c4060b0c151d3a3f4551a6a7cccda007191a22253e3fe7ecefffc5c60420232526" - "2833383a484a4c50535556585a5c5e606365666b73787d7f8aa4aaafb0c0d0aeaf" - "6e6fbe935e227b0503042d036603012f2e80821d03310f1c0424091e052b054404" - "0e2a80aa06240424042808340b4e43813709160a08183b45390363080930160521" - "031b05014038044b052f040a070907402027040c0936033a051a07040c07504937" - "330d33072e080a8126524b2b082a161a261c1417094e042409440d19070a064808" - "2709750b423e2a063b050a0651060105100305808b621e48080a80a65e22450b0a" - "060d133a060a362c041780b93c64530c48090a46451b4808530d49070a80f6460a" - "1d03474937030e080a0639070a813619073b031c56010f320d839b66750b80c48a" - "4c630d843010168faa8247a1b98239072a045c06260a460a28051382b05b654b04" - "39071140050b020e97f80884d62a09a2e781330f011d060e0408818c89046b050d" - "0309071092604709743c80f60a73087015467a140c140c57091980878147038542" - "0f1584501f060680d52b053e2101702d031a040281401f113a050181d02a82e680" - "f7294c040a04028311444c3d80c23c06010455051b3402810e2c04640c560a80ae" - "381d0d2c040907020e06809a83d80411030d0377045f060c04010f0c0438080a06" - "2808224e81540c1d03090736080e040907090780cb250a84060001030505060602" - "0706080709110a1c0b190c1a0d100e0c0f0410031212130916011704180119031a" - "071b011c021f1620032b032d0b2e01300431023201a702a902aa04ab08fa02fb05" - "fd02fe03ff09ad78798b8da23057588b8c901cdd0e0f4b4cfbfc2e2f3f5c5d5fe2" - "848d8e9192a9b1babbc5c6c9cadee4e5ff00041112293134373a3b3d494a5d848e" - "92a9b1b4babbc6cacecfe4e500040d0e11122931343a3b4546494a5e646584919b" - "9dc9cecf0d11293a3b4549575b5c5e5f64658d91a9b4babbc5c9dfe4e5f00d1145" - "4964658084b2bcbebfd5d7f0f183858ba4a6bebfc5c7cfdadb4898bdcdc6cecf49" - "4e4f57595e5f898e8fb1b6b7bfc1c6c7d71116175b5cf6f7feff806d71dedf0e1f" - "6e6f1c1d5f7d7eaeaf7fbbbc16171e1f46474e4f585a5c5e7e7fb5c5d4d5dcf0f1" - "f572738f747596262e2fa7afb7bfc7cfd7df9a00409798308f1fd2d4ceff4e4f5a" - "5b07080f10272feeef6e6f373d3f42459091536775c8c9d0d1d8d9e7feff00205f" - "2282df048244081b04061181ac0e80ab051f09811b03190801042f043404070301" - "070607110a500f1207550703041c0a090308030703020303030c0405030b06010e" - "15054e071b0757070206170c500443032d03010411060f0c3a041d255f206d046a" - "2580c80582b0031a0682fd03590716091809140c140c6a060a061a0659072b0546" - "0a2c040c040103310b2c041a060b0380ac060a062f314d0380a4083c030f033c07" - "38082b0582ff1118082f112d03210f210f808c048297190b158894052f053b0702" - "0e180980be22740c80d61a81100580df0bf29e033709815c1480b80880cb050a18" - "3b030a06380846080c06740b1e035a0459098083181c0a16094c04808a06aba40c" - "170431a10481da26070c050580a61081f50701202a064c04808d0480be031b030f" - "0d636f72652f7372632f756e69636f64652f756e69636f64655f646174612e7273" - "00e70a1000200000005000000028000000e70a1000200000005c00000016000000" - "0003000083042000910560005d13a0001217201f0c20601fef2ca02b2a30202c6f" - "a6e02c02a8602d1efb602e00fe20369eff6036fd01e136010a2137240de137ab0e" - "61392f18a139301c6148f31ea14c40346150f06aa1514f6f21529dbca15200cf61" - "5365d1a15300da215400e0e155aee26157ece42159d0e8a1592000ee59f0017f5a" - "00700007002d0101010201020101480b30151001650702060202010423011e1b5b" - "0b3a09090118040109010301052b033c082a180120370101010408040103070a02" - "1d013a0101010204080109010a021a010202390104020402020303011e0203010b" - "0239010405010204011402160601013a0101020104080107030a021e013b010101" - "0c01090128010301370101030503010407020b021d013a01020102010301050207" - "020b021c02390201010204080109010a021d014801040102030101080151010207" - "0c08620102090b0749021b0101010101370e01050102050b012409016604010601" - "0202021902040310040d01020206010f01000300031d021e021e02400201070801" - "020b09012d030101750222017603040209010603db0202013a0101070101010102" - "08060a0201301f310430070101050128090c022004020201033801010203010103" - "3a0802029803010d0107040106010302c6400001c32100038d0160200006690200" - "04010a200250020001030104011902050197021a120d012608190b2e0330010204" - "020227014306020202020c0108012f01330101030202050201012a020801ee0102" - "01040100010010101000020001e201950500030102050428030401a50200040002" - "5003460b31047b01360f290102020a033104020207013d03240501083e010c0234" - "090a0402015f0302010102060102019d010308150239020101010116010e070305" - "c308020301011701510102060101020101020102eb010204060201021b02550802" - "0101026a0101010206010165030204010500090102f5010a020101040190040202" - "0401200a280602040801090602032e0d010200070106010152160207010201027a" - "06030101020107010148020301010100020b023405050101010001060f00053b07" - "00013f0451010002002e0217000101030405080802071e0494030037043208010e" - "011605010f000701110207010201056401a00700013d04000400076d07006080f0" - "002f72757374632f63326637346333663932386165623530336631356234653965" - "6635373738653737663330353862382f6c6962726172792f616c6c6f632f737263" - "2f636f6c6c656374696f6e732f62747265652f6d61702f656e7472792e72730083" - "0e10006000000071010000360000002f72757374632f6332663734633366393238" - "61656235303366313562346539656635373738653737663330353862382f6c6962" - "726172792f616c6c6f632f7372632f636f6c6c656374696f6e732f62747265652f" - "6e6f64652e7273617373657274696f6e206661696c65643a20656467652e686569" - "676874203d3d2073656c662e686569676874202d203100f40e10005b000000af02" - "000009000000617373657274696f6e206661696c65643a207372632e6c656e2829" - "203d3d206473742e6c656e2829f40e10005b0000002f07000005000000f40e1000" - "5b000000af04000023000000f40e10005b000000ef040000240000006173736572" - "74696f6e206661696c65643a20656467652e686569676874203d3d2073656c662e" - "6e6f64652e686569676874202d2031000000f40e10005b000000f0030000090000" - "00181d10005f00000058020000300000000d0000000c000000040000000e000000" - "0f00000010000000000000000000000001000000110000006120446973706c6179" - "20696d706c656d656e746174696f6e2072657475726e656420616e206572726f72" - "20756e65787065637465646c792f72757374632f63326637346333663932386165" - "6235303366313562346539656635373738653737663330353862382f6c69627261" - "72792f616c6c6f632f7372632f737472696e672e727300009f1010004b00000006" - "0a00000e0000004572726f72454f46207768696c652070617273696e672061206c" - "697374454f46207768696c652070617273696e6720616e206f626a656374454f46" - "207768696c652070617273696e67206120737472696e67454f46207768696c6520" - "70617273696e6720612076616c7565657870656374656420603a60657870656374" - "656420602c60206f7220605d60657870656374656420602c60206f7220607d6065" - "78706563746564206964656e7465787065637465642076616c7565657870656374" - "656420602260696e76616c696420657363617065696e76616c6964206e756d6265" - "726e756d626572206f7574206f662072616e6765696e76616c696420756e69636f" - "646520636f646520706f696e74636f6e74726f6c2063686172616374657220285c" - "75303030302d5c75303031462920666f756e64207768696c652070617273696e67" - "206120737472696e676b6579206d757374206265206120737472696e67696e7661" - "6c69642076616c75653a206578706563746564206b657920746f2062652061206e" - "756d62657220696e2071756f746573666c6f6174206b6579206d75737420626520" - "66696e6974652028676f74204e614e206f72202b2f2d696e66296c6f6e65206c65" - "6164696e6720737572726f6761746520696e206865782065736361706574726169" - "6c696e6720636f6d6d61747261696c696e672063686172616374657273756e6578" - "70656374656420656e64206f662068657820657363617065726563757273696f6e" - "206c696d69742065786365656465644572726f72282c206c696e653a202c20636f" - "6c756d6e3a2000000035131000060000003b13100008000000431310000a000000" - "4826100001000000000000000000f03f0000000000002440000000000000594000" - "00000000408f40000000000088c34000000000006af8400000000080842e410000" - "0000d01263410000000084d797410000000065cdcd41000000205fa00242000000" - "e876483742000000a2941a6d42000040e59c30a2420000901ec4bcd64200003426" - "f56b0c430080e03779c3414300a0d8855734764300c84e676dc1ab43003d9160e4" - "58e143408cb5781daf154450efe2d6e41a4b4492d54d06cff08044f64ae1c7022d" - "b544b49dd9794378ea449102282c2a8b2045350332b7f4ad54450284fee471d989" - "4581121f2fe727c04521d7e6fae031f445ea8ca039593e294624b00888ef8d5f46" - "176e05b5b5b893469cc94622e3a6c846037cd8ea9bd0fe46824dc77261423347e3" - "2079cff91268471b695743b8179e47b1a1162ad3ced2471d4a9cf487820748a55c" - "c3f129633d48e7191a37fa5d724861a0e0c478f5a64879c818f6d6b2dc484c7dcf" - "59c6ef11499e5c43f0b76b4649c63354eca5067c495ca0b4b32784b14973c8a1a0" - "31e5e5498f3aca087e5e1b4a9a647ec50e1b514ac0fddd76d261854a307d951447" - "baba4a3e6edd6c6cb4f04acec9148887e1244b41fc196ae9195a4ba93d50e23150" - "904b134de45a3e64c44b57609df14d7df94b6db8046ea1dc2f4c44f3c2e4e4e963" - "4c15b0f31d5ee4984c1b9c70a5751dcf4c916166876972034df5f93fe9034f384d" - "72f88fe3c4626e4d47fb390ebbfda24d197ac8d129bdd74d9f983a4674ac0d4e64" - "9fe4abc88b424e3dc7ddd6ba2e774e0c39958c69faac4ea743ddf7811ce24e9194" - "d475a2a3164fb5b949138b4c4c4f11140eecd6af814f169911a7cc1bb64f5bffd5" - "d0bfa2eb4f99bf85e2b74521507f2f27db259755505ffbf051effc8a501b9d3693" - "15dec050624404f89a15f5507b5505b6015b2a516d55c311e1786051c82a345619" - "9794517a35c1abdfbcc9516cc158cb0b160052c7f12ebe8e1b345239aeba6d7222" - "6952c75929090f6b9f521dd8b965e9a2d352244e28bfa38b0853ad61f2ae8cae3e" - "530c7d57ed172d73534f5cade85df8a75363b3d86275f6dd531e70c75d09ba1254" - "254c39b58b6847542e9f87a2ae427d547dc39425ad49b2545cf4f96e18dce65473" - "71b88a1e931c55e846b316f3db5155a21860dcef528655ca1e78d3abe7bb553f13" - "2b64cb70f1550ed8353dfecc2556124e83cc3d405b56cb10d29f26089156fe94c6" - "47304ac5563d3ab859bc9cfa56662413b8f5a1305780ed172673ca6457e0e89def" - "0ffd99578cb1c2f5293ed057ef5d3373b44d04586b35009021613958c54200f469" - "b96f58bb298038e2d3a3582a34a0c6dac8d8583541487811fb0e59c1282debea5c" - "4359f172f8a525347859ad8f760f2f41ae59cc19aa69bde8e2593fa014c4eca217" - "5a4fc819f5a78b4d5a321d30f94877825a7e247c371b15b75a9e2d5b0562daec5a" - "82fc58437d08225ba33b2f949c8a565b8c0a3bb9432d8c5b97e6c4534a9cc15b3d" - "20b6e85c03f65b4da8e32234842b5c3049ce95a032615c7cdb41bb487f955c5b52" - "12ea1adfca5c79734bd270cb005d5750de064dfe345d6de49548e03d6a5dc4ae5d" - "2dac66a05d751ab5385780d45d1261e2066da0095eab7c4d244404405ed6db602d" - "5505745ecc12b978aa06a95e7f57e7165548df5eaf96502e358d135f5bbce47982" - "70485f72eb5d18a38c7e5f27b33aefe517b35ff15f096bdfdde75fedb7cb4557d5" - "1d60f4529f8b56a55260b127872eac4e87609df1283a5722bd60029759847635f2" - "60c3fc6f25d4c22661f4fbcb2e89735c61787d3fbd35c89161d65c8f2c433ac661" - "0c34b3f7d3c8fb618700d07a845d3162a9008499e5b46562d400e5ff1e229b6284" - "20ef5f53f5d062a5e8ea37a8320563cfa2e545527f3a63c185af6b938f70633267" - "9b4678b3a463fe40425856e0d9639f6829f7352c1064c6c2f3744337446478b330" - "521445796456e0bc665996af64360c36e0f7bde364438f43d875ad18651473544e" - "d3d84e65ecc7f41084478365e8f931156519b86561787e5abe1fee653d0b8ff8d6" - "d322660cceb2b6cc8857668f815fe4ff6a8d66f9b0bbeedf62c266389d6aea97fb" - "f666864405e57dba2c67d44a23af8ef46167891dec5ab2719667eb24a7f11e0ecc" - "6713770857d3880168d794ca2c08eb35680d3afd37ca656b684844fe629e1fa168" - "5ad5bdfb8567d568b14aad7a67c10a69af4eacace0b840695a62d7d718e77469f1" - "3acd0ddf20aa69d644a0688b54e0690c56c842ae69146a8f6b7ad31984496a7306" - "594820e57f6a08a4372d34efb36a0a8d853801ebe86a4cf0a686c1251f6b305628" - "f49877536bbb6b32317f55886baa067ffdde6abe6b2a646f5ecb02f36b353d0b36" - "7ec3276c820c8ec35db45d6cd1c7389aba90926cc6f9c640e934c76c37b8f89023" - "02fd6c23739b3a5621326deb4f42c9aba9666de6e392bb16549c6d70ce3b358eb4" - "d16d0cc28ac2b121066e8f722d331eaa3b6e9967fcdf524a716e7f81fb97e79ca5" - "6edf61fa7d2104db6e2c7dbcee94e2106f769c6b2a3a1b456f948306b508627a6f" - "3d122471457db06fcc166dcd969ce46f7f5cc880bcc31970cf397dd0551a507043" - "889c44eb20847054aac3152629b970e994349b6f73ef7011dd00c125a823715614" - "41312f9258716b5991fdbab68e71e3d77ade3432c371dc8d1916c2fef77153f19f" - "9b72fe2d72d4f643a107bf627289f49489c96e9772ab31faeb7b4acd720b5f7c73" - "8d4e0273cd765bd030e2367381547204bd9a6c73d074c722b6e0a173045279abe3" - "58d67386a657961cef0b7414c8f6dd71754174187a7455ced275749e98d1ea8147" - "ab7463ffc232b10ce1743cbf737fdd4f15750baf50dfd4a34a75676d920b65a680" - "75c008774efecfb475f1ca14e2fd03ea75d6fe4cad7e4220768c3ea0581e535476" - "2f4ec8eee5678976bb617a6adfc1bf76157d8ca22bd9f3765a9c2f8b76cf287770" - "83fb2d54035f772632bd9c14629377b07eecc3993ac8775c9ee7344049fe77f9c2" - "1021c8ed3278b8f354293aa96778a530aab388939d78675e4a70357cd27801f65c" - "cc421b07798233747f13e23c7931a0a82f4c0d72793dc8923b9f90a6794d7a770a" - "c734dc7970ac8a66fca0117a8c572d803b09467a6fad38608a8b7b7a656c237c36" - "37b17a7f472c1b0485e57a5e59f72145e61a7bdb973a35ebcf507bd23d8902e603" - "857b468d2b83df44ba7b4c38fbb10b6bf07b5f067a9ece85247cf687184642a759" - "7cfa54cf6b8908907c382ac3c6ab0ac47cc7f473b8560df97cf8f19066ac502f7d" - "3b971ac06b92637d0a3d21b00677987d4c8c295cc894ce7db0f79939fd1c037e9c" - "7500883ce4377e039300aa4bdd6d7ee25b404a4faaa27eda72d01ce354d77e908f" - "04e41b2a0d7fbad9826e513a427f299023cae5c8767f3374ac3c1f7bac7fa0c8eb" - "85f3cce17f2f72757374632f633266373463336639323861656235303366313562" - "346539656635373738653737663330353862382f6c6962726172792f616c6c6f63" - "2f7372632f636f6c6c656374696f6e732f62747265652f6e617669676174652e72" - "7300181d10005f000000c600000027000000181d10005f000000160200002f0000" - "00181d10005f000000a1000000240000002f686f6d652f7077616e672f2e636172" - "676f2f72656769737472792f7372632f696e6465782e6372617465732e696f2d36" - "6631376432326262613135303031662f73657264655f6a736f6e2d312e302e3133" - "352f7372632f726561642e727300a81d10005f000000a001000045000000a81d10" - "005f000000a50100003d000000a81d10005f000000ad0100001a000000a81d1000" - "5f000000fa01000013000000a81d10005f000000030200003e000000a81d10005f" - "000000ff01000033000000a81d10005f000000090200003a000000a81d10005f00" - "00006802000019000000ffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffff0000010002000300040005000600070008000900ffffffffffff" - "ffffffffffffffff0a000b000c000d000e000f00ffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffff0a000b000c000d000e000f00ffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffff000010002000300040" - "0050006000700080009000ffffffffffffffffffffffffffffa000b000c000d000" - "e000f000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffa000b000c000d000e000" - "f000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - "ffffffffffffffffffffff0d0000000c000000040000000e0000000f0000001000" - "00002f727573742f646570732f646c6d616c6c6f632d302e322e362f7372632f64" - "6c6d616c6c6f632e7273617373657274696f6e206661696c65643a207073697a65" - "203e3d2073697a65202b206d696e5f6f7665726865616400a022100029000000a8" - "04000009000000617373657274696f6e206661696c65643a207073697a65203c3d" - "2073697a65202b206d61785f6f766572686561640000a022100029000000ae0400" - "000d0000000100000000000000656e74697479206e6f7420666f756e647065726d" - "697373696f6e2064656e696564636f6e6e656374696f6e2072656675736564636f" - "6e6e656374696f6e207265736574686f737420756e726561636861626c656e6574" - "776f726b20756e726561636861626c65636f6e6e656374696f6e2061626f727465" - "646e6f7420636f6e6e65637465646164647265737320696e207573656164647265" - "7373206e6f7420617661696c61626c656e6574776f726b20646f776e62726f6b65" - "6e2070697065656e7469747920616c7265616479206578697374736f7065726174" - "696f6e20776f756c6420626c6f636b6e6f742061206469726563746f7279697320" - "61206469726563746f72796469726563746f7279206e6f7420656d707479726561" - "642d6f6e6c792066696c6573797374656d206f722073746f72616765206d656469" - "756d66696c6573797374656d206c6f6f70206f7220696e646972656374696f6e20" - "6c696d69742028652e672e2073796d6c696e6b206c6f6f70297374616c65206e65" - "74776f726b2066696c652068616e646c65696e76616c696420696e707574207061" - "72616d65746572696e76616c6964206461746174696d6564206f75747772697465" - "207a65726f6e6f2073746f726167652073706163657365656b206f6e20756e7365" - "656b61626c652066696c6566696c6573797374656d2071756f7461206578636565" - "64656466696c6520746f6f206c617267657265736f757263652062757379657865" - "63757461626c652066696c652062757379646561646c6f636b63726f73732d6465" - "76696365206c696e6b206f722072656e616d65746f6f206d616e79206c696e6b73" - "696e76616c69642066696c656e616d65617267756d656e74206c69737420746f6f" - "206c6f6e676f7065726174696f6e20696e746572727570746564756e737570706f" - "72746564756e657870656374656420656e64206f662066696c656f7574206f6620" - "6d656d6f72796f74686572206572726f72756e63617465676f72697a6564206572" - "726f7220286f73206572726f72202900000001000000000000003d2610000b0000" - "0048261000010000006f7065726174696f6e207375636365737366756c10000000" - "1100000012000000100000001000000013000000120000000d0000000e00000015" - "0000000c0000000b00000015000000150000000f0000000e000000130000002600" - "00003800000019000000170000000c000000090000000a00000010000000170000" - "00190000000e0000000d00000014000000080000001b0000000e00000010000000" - "16000000150000000b000000160000000d0000000b000000130000005023100060" - "231000712310008323100093231000a3231000b6231000c8231000d5231000e323" - "1000f8231000042410000f24100024241000392410004824100056241000692410" - "008f241000c7241000e0241000f7241000032510000c2510001625100026251000" - "3d251000562510006425100071251000852510008d251000a8251000b6251000c6" - "251000dc251000f1251000fc251000122610001f2610002a26100000ac3a046e61" - "6d65000e0d7761736d5f6c69622e7761736d01f4396000325f5a4e313073657264" - "655f6a736f6e326465313066726f6d5f736c696365313768313163653038373736" - "34633961376230450188015f5a4e313073657264655f6a736f6e3576616c756532" - "646537375f244c5424696d706c247532302473657264652e2e64652e2e44657365" - "7269616c697a652475323024666f72247532302473657264655f6a736f6e2e2e76" - "616c75652e2e56616c7565244754243131646573657269616c697a653137683331" - "653531373831633833363837353945020e5f5f727573745f6465616c6c6f630345" - "5f5a4e313073657264655f6a736f6e347265616439536c69636552656164313770" - "6f736974696f6e5f6f665f696e6465783137683236623431383938353234383332" - "39364504435f5a4e38646c6d616c6c6f6338646c6d616c6c6f633137446c6d616c" - "6c6f63244c54244124475424366d616c6c6f633137686536353933396134633839" - "376363313545054f5f5a4e34636f726533707472343564726f705f696e5f706c61" - "6365244c542473657264655f6a736f6e2e2e76616c75652e2e56616c7565244754" - "243137683533326265333033376461316237656445064a5f5a4e31307365726465" - "5f6a736f6e3264653231446573657269616c697a6572244c542452244754243131" - "70617273655f6964656e743137683663353964643731393635353139313045074b" - "5f5a4e313073657264655f6a736f6e3264653231446573657269616c697a657224" - "4c54245224475424313270617273655f6e756d6265723137683738336134316134" - "623931306464323045084c5f5a4e313073657264655f6a736f6e32646532314465" - "73657269616c697a6572244c54245224475424313370617273655f646563696d61" - "6c3137683661306333363832326663336530306145094d5f5a4e31307365726465" - "5f6a736f6e3264653231446573657269616c697a6572244c542452244754243134" - "70617273655f6578706f6e656e7431376833366464376462643233653461346562" - "450a555f5a4e313073657264655f6a736f6e3264653231446573657269616c697a" - "6572244c54245224475424323270617273655f646563696d616c5f6f766572666c" - "6f7731376833613030656365646638363031386433450b4d5f5a4e313073657264" - "655f6a736f6e3264653231446573657269616c697a6572244c5424522447542431" - "346636345f66726f6d5f7061727473313768633863316239626161613836666637" - "33450c565f5a4e313073657264655f6a736f6e3264653231446573657269616c69" - "7a6572244c54245224475424323370617273655f6578706f6e656e745f6f766572" - "666c6f7731376830343762396637333562616463666138450d4f5f5a4e31307365" - "7264655f6a736f6e3264653231446573657269616c697a6572244c542452244754" - "24313670617273655f616e795f6e756d6265723137683931643533303465356139" - "6363663531450e515f5a4e313073657264655f6a736f6e32646532314465736572" - "69616c697a6572244c54245224475424313870617273655f6c6f6e675f696e7465" - "67657231376864383130373866346133316332626532450f3d5f5a4e3130736572" - "64655f6a736f6e356572726f72354572726f7231326669785f706f736974696f6e" - "313768386631666565323432343761346639634510435f5a4e35616c6c6f633772" - "61775f7665633139526177566563244c54245424432441244754243867726f775f" - "6f6e65313768663733333137633566643665626336364511645f5a4e37305f244c" - "5424616c6c6f632e2e7665632e2e566563244c5424542443244124475424247532" - "302461732475323024636f72652e2e6f70732e2e64726f702e2e44726f70244754" - "243464726f703137686431353834386335383231633466666545124f5f5a4e3463" - "6f726533707472343564726f705f696e5f706c616365244c542473657264655f6a" - "736f6e2e2e6572726f722e2e4572726f7224475424313768663837633864366463" - "396162346263354513695f5a4e37305f244c542473657264655f6a736f6e2e2e72" - "6561642e2e536c6963655265616424753230246173247532302473657264655f6a" - "736f6e2e2e726561642e2e52656164244754243970617273655f73747231376861" - "62653863353535633862636433353545143c5f5a4e357365726465326465375669" - "7369746f72313876697369745f626f72726f7765645f7374723137683435643731" - "31633837313638633266364515335f5a4e35616c6c6f63377261775f7665633132" - "68616e646c655f6572726f72313768393762376462643066373264643738384516" - "3a5f5a4e313073657264655f6a736f6e32646531325061727365724e756d626572" - "35766973697431376838366238393638313662613130613765451781015f5a4e37" - "355f244c542473657264655f6a736f6e2e2e64652e2e4d6170416363657373244c" - "5424522447542424753230246173247532302473657264652e2e64652e2e4d6170" - "4163636573732447542431336e6578745f6b65795f7365656431326861735f6e65" - "78745f6b6579313768356461326634303536653538313464394518695f5a4e3730" - "5f244c542473657264652e2e64652e2e696d706c732e2e537472696e6756697369" - "746f7224753230246173247532302473657264652e2e64652e2e56697369746f72" - "244754243976697369745f73747231376835356436653830653061376366383938" - "4519755f5a4e37355f244c542473657264655f6a736f6e2e2e64652e2e4d617041" - "6363657373244c5424522447542424753230246173247532302473657264652e2e" - "64652e2e4d61704163636573732447542431356e6578745f76616c75655f736565" - "6431376865633835363737653830316539393133451a565f5a4e35616c6c6f6331" - "31636f6c6c656374696f6e73356274726565336d6170323542547265654d617024" - "4c54244b24432456244324412447542436696e7365727431376834643164623464" - "613838343264346665451b81015f5a4e39395f244c5424616c6c6f632e2e636f6c" - "6c656374696f6e732e2e62747265652e2e6d61702e2e42547265654d6170244c54" - "244b244324562443244124475424247532302461732475323024636f72652e2e6f" - "70732e2e64726f702e2e44726f70244754243464726f7031376835346633306630" - "323133646334313362451c5d5f5a4e36355f244c542473657264655f6a736f6e2e" - "2e76616c75652e2e56616c7565247532302461732475323024636f72652e2e636d" - "702e2e5061727469616c4571244754243265713137683162323138393234373831" - "3936633830451d8b015f5a4e3130385f244c5424616c6c6f632e2e636f6c6c6563" - "74696f6e732e2e62747265652e2e6d61702e2e49746572244c54244b2443245624" - "475424247532302461732475323024636f72652e2e697465722e2e747261697473" - "2e2e6974657261746f722e2e4974657261746f7224475424346e65787431376835" - "363664323036316535613937646164451e08616c6c6f636174651f11636f6d7061" - "72655f6163636f756e744944205c5f5a4e35355f244c5424737472247532302461" - "73247532302473657264655f6a736f6e2e2e76616c75652e2e696e6465782e2e49" - "6e646578244754243130696e6465785f696e746f31376864333238633634636161" - "3964313761634521325f5a4e34636f726536726573756c743133756e777261705f" - "6661696c6564313768663839396364303037373637303035314522325f5a4e3463" - "6f7265366f7074696f6e3133756e777261705f6661696c65643137683335353139" - "64653938613737363134664523385f5a4e35616c6c6f63377261775f7665633137" - "63617061636974795f6f766572666c6f7731376834393964343832613965643537" - "3135614524305f5a4e34636f72653970616e69636b696e673970616e69635f666d" - "74313768363534306363623264356664633361624525415f5a4e38646c6d616c6c" - "6f6338646c6d616c6c6f633137446c6d616c6c6f63244c54244124475424346672" - "65653137683339383334616161616533653839343645262c5f5a4e34636f726539" - "70616e69636b696e673570616e6963313768303465656239313764643933633232" - "3945270e5f5f727573745f7265616c6c6f63284a5f5a4e38646c6d616c6c6f6338" - "646c6d616c6c6f633137446c6d616c6c6f63244c542441244754243132756e6c69" - "6e6b5f6368756e6b3137683933346533646333383362623538613345294b5f5a4e" - "38646c6d616c6c6f6338646c6d616c6c6f633137446c6d616c6c6f63244c542441" - "244754243133646973706f73655f6368756e6b3137683665306363636434353836" - "3537343633452a445f5a4e34636f726535736c69636535696e6465783236736c69" - "63655f73746172745f696e6465785f6c656e5f6661696c31376866393161336166" - "653837623164343433452b625f5a4e34636f726533666d74336e756d33696d7035" - "325f244c5424696d706c2475323024636f72652e2e666d742e2e446973706c6179" - "2475323024666f7224753230247533322447542433666d74313768626633653032" - "32383438336533373561452c3a5f5a4e34636f72653970616e69636b696e673138" - "70616e69635f626f756e64735f636865636b313768336436623861613463383034" - "39363632452d305f5a4e34636f726533666d74336e756d33696d7037666d745f75" - "363431376864353231666136656636613036373261452e11727573745f62656769" - "6e5f756e77696e642f385f5a4e34636f726533666d7439466f726d617474657231" - "327061645f696e74656772616c3137686334656130376130626331333536633445" - "30465f5a4e34636f726533666d7439466f726d617474657231327061645f696e74" - "656772616c313277726974655f7072656669783137686139613433323830623630" - "30366431324531425f5a4e34636f726535736c69636535696e6465783234736c69" - "63655f656e645f696e6465785f6c656e5f6661696c313768303838623536653239" - "3962656161616645322e5f5a4e34636f726533666d7439466f726d617474657233" - "706164313768343736396165333839333734636335314533495f5a4e34345f244c" - "54242452462454247532302461732475323024636f72652e2e666d742e2e446973" - "706c61792447542433666d74313768376666346430623836303963323437324534" - "475f5a4e34325f244c54242452462454247532302461732475323024636f72652e" - "2e666d742e2e44656275672447542433666d743137683361366261613162623437" - "61643230344535265f5a4e34636f726533666d7435777269746531376839333535" - "34653462653731663263376145365c5f5a4e34636f726533666d74336e756d3530" - "5f244c5424696d706c2475323024636f72652e2e666d742e2e4465627567247532" - "3024666f7224753230247533322447542433666d74313768353533393862313635" - "353064353237654537405f5a4e34636f726535736c69636535696e646578323273" - "6c6963655f696e6465785f6f726465725f6661696c313768353862336536383666" - "653333373030654538535f5a4e34636f72653463686172376d6574686f64733232" - "5f244c5424696d706c2475323024636861722447542431366573636170655f6465" - "6275675f657874313768656366613566303431373437393039384539345f5a4e34" - "636f726537756e69636f6465397072696e7461626c6535636865636b3137683664" - "6136346638306663313630633761453a325f5a4e34636f7265337374723136736c" - "6963655f6572726f725f6661696c31376862303364323439386438646362363433" - "453b355f5a4e34636f7265337374723139736c6963655f6572726f725f6661696c" - "5f727431376832616462643139306563313832373933453c645f5a4e37315f244c" - "5424636f72652e2e6f70732e2e72616e67652e2e52616e6765244c542449647824" - "475424247532302461732475323024636f72652e2e666d742e2e44656275672447" - "542433666d7431376836636632383632303536616535653233453d465f5a4e3431" - "5f244c542463686172247532302461732475323024636f72652e2e666d742e2e44" - "656275672447542433666d7431376865613566643964626339343936626665453e" - "625f5a4e34636f726533666d74336e756d33696d7035325f244c5424696d706c24" - "75323024636f72652e2e666d742e2e446973706c61792475323024666f72247532" - "30246933322447542433666d743137686365643930633761363339633031646445" - "3fce015f5a4e35616c6c6f633131636f6c6c656374696f6e73356274726565346e" - "6f64653132374e6f6465526566244c5424616c6c6f632e2e636f6c6c656374696f" - "6e732e2e62747265652e2e6e6f64652e2e6d61726b65722e2e4479696e67244324" - "4b24432456244324616c6c6f632e2e636f6c6c656374696f6e732e2e6274726565" - "2e2e6e6f64652e2e6d61726b65722e2e4c6561664f72496e7465726e616c244754" - "2432316465616c6c6f636174655f616e645f617363656e64313768353839613732" - "6639343233626663656245409a025f5a4e35616c6c6f633131636f6c6c65637469" - "6f6e73356274726565346e6f646532313448616e646c65244c5424616c6c6f632e" - "2e636f6c6c656374696f6e732e2e62747265652e2e6e6f64652e2e4e6f64655265" - "66244c5424616c6c6f632e2e636f6c6c656374696f6e732e2e62747265652e2e6e" - "6f64652e2e6d61726b65722e2e4d75742443244b24432456244324616c6c6f632e" - "2e636f6c6c656374696f6e732e2e62747265652e2e6e6f64652e2e6d61726b6572" - "2e2e496e7465726e616c24475424244324616c6c6f632e2e636f6c6c656374696f" - "6e732e2e62747265652e2e6e6f64652e2e6d61726b65722e2e4564676524475424" - "3130696e736572745f666974313768633861306366353339656666303131314541" - "92025f5a4e35616c6c6f633131636f6c6c656374696f6e73356274726565346e6f" - "646532313248616e646c65244c5424616c6c6f632e2e636f6c6c656374696f6e73" - "2e2e62747265652e2e6e6f64652e2e4e6f6465526566244c5424616c6c6f632e2e" - "636f6c6c656374696f6e732e2e62747265652e2e6e6f64652e2e6d61726b65722e" - "2e4d75742443244b24432456244324616c6c6f632e2e636f6c6c656374696f6e73" - "2e2e62747265652e2e6e6f64652e2e6d61726b65722e2e496e7465726e616c2447" - "5424244324616c6c6f632e2e636f6c6c656374696f6e732e2e62747265652e2e6e" - "6f64652e2e6d61726b65722e2e4b56244754243573706c69743137686430396134" - "386237613831363331616145425a5f5a4e36315f244c542473657264655f6a736f" - "6e2e2e6572726f722e2e4572726f72247532302461732475323024636f72652e2e" - "666d742e2e44656275672447542433666d74313768343032353764366634326532" - "396237344543595f5a4e36305f244c5424616c6c6f632e2e737472696e672e2e53" - "7472696e67247532302461732475323024636f72652e2e666d742e2e446973706c" - "61792447542433666d74313768636534323236616131663732366331634544615f" - "5a4e35385f244c5424616c6c6f632e2e737472696e672e2e537472696e67247532" - "302461732475323024636f72652e2e666d742e2e57726974652447542439777269" - "74655f73747231376835393964396535373839343664643938452e31393245575f" - "5a4e35385f244c5424616c6c6f632e2e737472696e672e2e537472696e67247532" - "302461732475323024636f72652e2e666d742e2e44656275672447542433666d74" - "313768623637326562313939633335643138364546555f5a4e35335f244c542463" - "6f72652e2e666d742e2e4572726f72247532302461732475323024636f72652e2e" - "666d742e2e44656275672447542433666d74313768663761653238353562323439" - "64626335452e3734474c5f5a4e34636f726533707472343264726f705f696e5f70" - "6c616365244c5424616c6c6f632e2e737472696e672e2e537472696e6724475424" - "313768376236353738393966393837353963624548475f5a4e313073657264655f" - "6a736f6e347265616439536c696365526561643139736b69705f746f5f65736361" - "70655f736c6f77313768343738366336653232346661323366324549465f5a4e35" - "616c6c6f63337665633136566563244c5424542443244124475424313765787465" - "6e645f66726f6d5f736c6963653137686462613134663734663865323236646345" - "4a2f5f5a4e313073657264655f6a736f6e34726561643661735f73747231376866" - "636436626234313731373865366635454b435f5a4e35616c6c6f63377261775f76" - "65633139526177566563244c54245424432441244754243867726f775f6f6e6531" - "376836366638363461663034626564326232454c3e5f5a4e313073657264655f6a" - "736f6e3472656164323070617273655f756e69636f64655f657363617065313768" - "39363430666363616264303034613064454d725f5a4e37305f244c542473657264" - "655f6a736f6e2e2e726561642e2e536c6963655265616424753230246173247532" - "302473657264655f6a736f6e2e2e726561642e2e52656164244754243137646563" - "6f64655f6865785f65736361706531376834376265353936383535663830346461" - "454e355f5a4e313073657264655f6a736f6e347265616431317065656b5f6f725f" - "656f6631376837336362313436306531616339386135454f5a5f5a4e35616c6c6f" - "63377261775f7665633230526177566563496e6e6572244c542441244754243772" - "6573657276653231646f5f726573657276655f616e645f68616e646c6531376837" - "66656665376563326164336435616245502e5f5a4e313073657264655f6a736f6e" - "3472656164356572726f7231376865663535323764333333633963323666455130" - "5f5a4e34636f726533666d743557726974653977726974655f666d743137686133" - "31656164363637646336373865304552635f5a4e35385f244c5424616c6c6f632e" - "2e737472696e672e2e537472696e67247532302461732475323024636f72652e2e" - "666d742e2e577269746524475424313077726974655f6368617231376832313433" - "393163623865623135326336452e31393353325f5a4e35616c6c6f63377261775f" - "766563313166696e6973685f67726f773137683533383539626133383962373164" - "333545544b5f5a4e35616c6c6f63377261775f7665633230526177566563496e6e" - "6572244c54244124475424313467726f775f616d6f7274697a6564313768393863" - "3336346663343566336431323445550a727573745f70616e696356375f5a4e3463" - "6f72653570616e6963313250616e69635061796c6f61643661735f737472313768" - "363134396631343264396132653032654557505f5a4e38646c6d616c6c6f633864" - "6c6d616c6c6f633137446c6d616c6c6f63244c542441244754243138696e736572" - "745f6c617267655f6368756e6b3137686566653835316132373538326461376245" - "58455f5a4e3373746433737973396261636b747261636532365f5f727573745f65" - "6e645f73686f72745f6261636b7472616365313768346463336465343764323230" - "323162394559585f5a4e337374643970616e69636b696e673139626567696e5f70" - "616e69635f68616e646c657232385f24753762242475376224636c6f7375726524" - "75376424247537642431376865313761333937376638396331313738455a3b5f5a" - "4e337374643970616e69636b696e673230727573745f70616e69635f776974685f" - "686f6f6b31376837373665373963396636353931626535455b83015f5a4e39395f" - "244c54247374642e2e70616e69636b696e672e2e626567696e5f70616e69635f68" - "616e646c65722e2e5374617469635374725061796c6f6164247532302461732475" - "323024636f72652e2e70616e69632e2e50616e69635061796c6f61642447542436" - "61735f73747231376865623366373232643232346534326638455c066d656d636d" - "705d365f5a4e3137636f6d70696c65725f6275696c74696e73336d656d376d656d" - "6d6f766531376863383366393136386635323861656536455e076d656d6d6f7665" - "5f066d656d637079071201000f5f5f737461636b5f706f696e746572090a010007" - "2e726f6461746100550970726f64756365727302086c616e677561676501045275" - "7374000c70726f6365737365642d62790105727573746325312e38332e302d6e69" - "6768746c79202863326637346333663920323032342d30392d30392900490f7461" - "726765745f6665617475726573042b0a6d756c746976616c75652b0f6d75746162" - "6c652d676c6f62616c732b0f7265666572656e63652d74797065732b087369676e" - "2d657874"; - -extern std::string const zkProofHex = +extern std::string const zkProofWasmHex = "0061736d0100000001600f60037f7f7f017f60027f7f017f60027f7f0060" "037f7f7f0060000060057f7f7f7f7f0060047f7f7f7f0060067f7f7f7f7f" "7f0060017f017f6000017f60017f0060047f7f7f7f017f60027e7e017f60" @@ -5385,7 +3242,7 @@ extern std::string const zkProofHex = "676c6f62616c732b0f7265666572656e63652d74797065732b087369676e" "2d657874"; -extern std::string const sp1_wasm = +extern std::string const sp1WasmHex = "0061736d0100000001630f60027f7f0060037f7f7f0060027f7f017f6003" "7f7f7f017f60017f0060047f7f7f7f0060017f017f60057f7f7f7f7f0060" "047f7f7f7f017f6000017f60077f7e7e7e7e7e7e0060000060097f7e7e7e" @@ -10757,7 +8614,7 @@ extern std::string const sp1_wasm = "2b087369676e2d6578742b0f7265666572656e63652d74797065732b0a6d" "756c746976616c7565"; -std::string const ledgerSqnHex = +std::string const ledgerSqnWasmHex = "0061736d01000000010e0360027f7f017f6000006000017f02160103656e" "760e6765745f6c65646765725f73716e000003030201020503010002063e" "0a7f004180080b7f004180080b7f004180100b7f004180100b7f00418090" @@ -10778,7 +8635,7 @@ std::string const ledgerSqnHex = "732b087369676e2d6578742b0f7265666572656e63652d74797065732b0a" "6d756c746976616c7565"; -std::string const allHostFunctionsHex = +std::string const allHostFunctionsWasmHex = "0061736d0100000001540c60027f7f017f60047f7f7f7f017f60037f7f7f" "017f60057f7f7f7f7f017f60017f017f60037f7f7f0060037f7f7e017f60" "087f7f7f7f7f7f7f7f017f60067f7f7f7f7f7f017f60017f0060027f7f00" @@ -11774,32 +9631,6 @@ std::string const deepRecursionHex = "2d676c6f62616c732b0f7265666572656e63652d74797065732b087369676e" "2d657874"; -extern std::string const reqNonexistentField = - "0061736d0100000001120360027f7f0060047f7f7f7f017f6000017f02200108686f73745f" - "6c6962136765745f74785f6e65737465645f6669656c640001030403020000050301001006" - "19037f01418080c0000b7f00418080c0000b7f00418080c0000b072e04066d656d6f727902" - "000666696e69736800010a5f5f646174615f656e6403010b5f5f686561705f626173650302" - "0abc04035f01037f230041d0206b220124002001410c6a220241802010032001418c206a22" - "0041c400100320004189803c10022000410010022000418a803810022000418d801c100220" - "0020012802cc2020024180201000200141d0206a240041004a0b6101027f230041106b2103" - "024020002802402202413d6b41bf7f490d002003200136020c4100210103402002413f4b0d" - "01200020026a2003410c6a20016a2d00003a00002000200028024041016a22023602402001" - "41016a22014104470d000b0b0bf70201037f200141104f044002402000410020006b410371" - "22036a220220004d0d0020030440200321040340200041003a0000200041016a2100200441" - "016b22040d000b0b200341016b4107490d000340200041003a0000200041076a41003a0000" - "200041066a41003a0000200041056a41003a0000200041046a41003a0000200041036a4100" - "3a0000200041026a41003a0000200041016a41003a0000200041086a22002002470d000b0b" - "2002200120036b2201417c716a220020024b0440034020024100360200200241046a220220" - "00490d000b0b200141037121010b02402000200020016a22034f0d00200141077122020440" - "0340200041003a0000200041016a2100200241016b22020d000b0b200141016b4107490d00" - "0340200041003a0000200041076a41003a0000200041066a41003a0000200041056a41003a" - "0000200041046a41003a0000200041036a41003a0000200041026a41003a0000200041016a" - "41003a0000200041086a22002003470d000b0b0b004d0970726f64756365727302086c616e" - "6775616765010452757374000c70726f6365737365642d6279010572757374631d312e3835" - "2e31202834656231363132353020323032352d30332d31352900490f7461726765745f6665" - "617475726573042b0f6d757461626c652d676c6f62616c732b087369676e2d6578742b0f72" - "65666572656e63652d74797065732b0a6d756c746976616c7565"; - extern std::string const hfPerfTest = "0061736d0100000001180460037f7f7e017f60057f7f7f7f7f017f600000" "6000017f021d0203656e760974726163655f6e756d000003656e76057472" @@ -11837,17 +9668,7 @@ extern std::string const hfPerfTest = "6d757461626c652d676c6f62616c732b087369676e2d6578742b0f726566" "6572656e63652d74797065732b0a6d756c746976616c7565"; -extern std::string const opcCallPerfTest = - "0061736d010000000112046000017e60027f7f017f6000017f6000000304" - "0303020104050170010101050401008002061c047f0141b08880040b7f00" - "41ac080b7f0041b08880040b7f01410a0b073305066d656d6f7279020004" - "6d61696e0002047465737400010a5f5f646174615f656e6403010b5f5f68" - "6561705f6261736503020a4e030400010f0b3b04017f017c017f027e4180" - "84afdf0021004494b768e11b6c9b42210141d1e3c6012102024003401000" - "200041016b220041004a0d000b0b41010f0b0b01017f1001210220020f0b" - "0b0e01004180080b07623a2025660a00"; - -extern std::string const keyletHostFunctions = +extern std::string const allKeyletsWasmHex = "0061736d01000000014d0960057f7f7f7f7f017f60047f7f7f7f017f60037f7f7f017f6008" "7f7f7f7f7f7f7f7f017f60067f7f7f7f7f7f017f60037f7f7e017f60077f7f7f7f7f7f7f01" "7f60057f7f7f7f7f006000017f02de031208686f73745f6c6962057472616365000008686f" @@ -12033,7 +9854,7 @@ extern std::string const keyletHostFunctions = "7369676e2d6578742b0f7265666572656e63652d74797065732b0a6d756c746976616c756" "5"; -extern std::string const codecovWasm = +extern std::string const codecovTestsWasmHex = "0061736d0100000001570b60027f7f017f60047f7f7f7f017f60057f7f7f7f7f017f60037f" "7f7f017f60067f7f7f7f7f7f017f6000017f60017f017f60087f7f7f7f7f7f7f7f017f6003" "7f7f7e017f60077f7f7f7f7f7f7f017f60047f7f7f7f0002a90a2d08686f73745f6c696209" @@ -12263,7 +10084,7 @@ extern std::string const codecovWasm = "6f62616c732b087369676e2d6578742b0f7265666572656e63652d74797065732b0a6d756c" "746976616c7565"; -extern std::string const floatHex = +extern std::string const floatTestsWasmHex = "0061736d0100000001430860057f7f7f7f7f017f60047e7f7f7f017f60047f7f7f7f017f60" "057f7e7f7f7f017f60077f7f7f7f7f7f7f017f60067f7f7f7f7f7f017f60037f7f7e017f60" "00017f02c9020e08686f73745f6c6962057472616365000008686f73745f6c69620e666c6f" diff --git a/src/test/app/wasm_fixtures/fixtures.h b/src/test/app/wasm_fixtures/fixtures.h index f3fdf66aae..0e7e3785ea 100644 --- a/src/test/app/wasm_fixtures/fixtures.h +++ b/src/test/app/wasm_fixtures/fixtures.h @@ -23,45 +23,29 @@ #include -extern std::string const ledgerSqnHex; +extern std::string const ledgerSqnWasmHex; -extern std::string const allHostFunctionsHex; +extern std::string const allHostFunctionsWasmHex; extern std::string const deepRecursionHex; -extern std::string const tx_js; +extern std::string const fibWasmHex; -extern std::string const lo_js; +extern std::string const b58WasmHex; -extern std::string const lo_js2; +extern std::string const sha512PureWasmHex; -extern std::string const fib32Hex; +extern std::string const zkProofWasmHex; -extern std::string const fib64Hex; - -extern std::string const b58Hex; - -extern std::string const sha512PureHex; - -extern std::string const checkJsonHex; - -extern std::string const compareJsonHex; - -extern std::string const zkProofHex; - -extern std::string const sp1_wasm; - -extern std::string const reqNonexistentField; +extern std::string const sp1WasmHex; extern std::string const hfPerfTest; -extern std::string const opcCallPerfTest; +extern std::string const allKeyletsWasmHex; -extern std::string const keyletHostFunctions; +extern std::string const codecovTestsWasmHex; -extern std::string const codecovWasm; - -extern std::string const floatHex; +extern std::string const floatTestsWasmHex; extern std::string const float0Hex; diff --git a/src/test/app/wasm_fixtures/float_tests/Cargo.lock b/src/test/app/wasm_fixtures/float_tests/Cargo.lock new file mode 100644 index 0000000000..972bf3ce61 --- /dev/null +++ b/src/test/app/wasm_fixtures/float_tests/Cargo.lock @@ -0,0 +1,15 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "float_tests" +version = "0.0.1" +dependencies = [ + "xrpl-std", +] + +[[package]] +name = "xrpl-std" +version = "0.0.1" +source = "git+https://github.com/ripple/craft.git?branch=main#94fb247e0c21b9e7fecb91ce71ef7f74ef4a7931" diff --git a/src/test/app/wasm_fixtures/float_tests/Cargo.toml b/src/test/app/wasm_fixtures/float_tests/Cargo.toml new file mode 100644 index 0000000000..b4dec2aa50 --- /dev/null +++ b/src/test/app/wasm_fixtures/float_tests/Cargo.toml @@ -0,0 +1,21 @@ +[package] +name = "float_tests" +version = "0.0.1" +edition = "2024" + +# This empty workspace definition keeps this project independent of the parent workspace +[workspace] + +[lib] +crate-type = ["cdylib"] + +[profile.release] +lto = true +opt-level = 's' +panic = "abort" + +[dependencies] +xrpl-std = { git = "https://github.com/ripple/craft.git", branch = "main", package = "xrpl-std" } + +[profile.dev] +panic = "abort" diff --git a/src/test/app/wasm_fixtures/float_tests/src/lib.rs b/src/test/app/wasm_fixtures/float_tests/src/lib.rs new file mode 100644 index 0000000000..9688ebd602 --- /dev/null +++ b/src/test/app/wasm_fixtures/float_tests/src/lib.rs @@ -0,0 +1,460 @@ +#![allow(unused_imports)] +#![allow(unused_variables)] +#![cfg_attr(target_arch = "wasm32", no_std)] + +#[cfg(not(target_arch = "wasm32"))] +extern crate std; + +use xrpl_std::core::locator::Locator; +use xrpl_std::decode_hex_32; +use xrpl_std::host::trace::DataRepr::AsHex; +use xrpl_std::host::trace::{trace, trace_data, trace_float, trace_num, DataRepr}; +use xrpl_std::host::{ + cache_ledger_obj, float_add, float_compare, float_divide, float_from_int, float_from_uint, + float_log, float_multiply, float_pow, float_root, float_set, float_subtract, + get_ledger_obj_array_len, get_ledger_obj_field, get_ledger_obj_nested_field, + trace_opaque_float, FLOAT_NEGATIVE_ONE, FLOAT_ONE, FLOAT_ROUNDING_MODES_TO_NEAREST, +}; +use xrpl_std::sfield; +use xrpl_std::sfield::{ + Account, AccountTxnID, Balance, Domain, EmailHash, Flags, LedgerEntryType, MessageKey, + OwnerCount, PreviousTxnID, PreviousTxnLgrSeq, RegularKey, Sequence, TicketCount, TransferRate, +}; + +fn test_float_from_wasm() { + let _ = trace("\n$$$ test_float_from_wasm $$$"); + + let mut f: [u8; 8] = [0u8; 8]; + if 8 == unsafe { float_from_int(12300, f.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) } { + let _ = trace_float(" float from i64 12300:", &f); + let _ = trace_data(" float from i64 12300 as HEX:", &f, AsHex); + } else { + let _ = trace(" float from i64 12300: failed"); + } + + let u64_value: u64 = 12300; + if 8 == unsafe { + float_from_uint( + &u64_value as *const u64 as *const u8, + 8, + f.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + } { + let _ = trace_float(" float from u64 12300:", &f); + } else { + let _ = trace(" float from u64 12300: failed"); + } + + if 8 == unsafe { float_set(2, 123, f.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) } { + let _ = trace_float(" float from exp 2, mantissa 123:", &f); + } else { + let _ = trace(" float from exp 2, mantissa 3: failed"); + } + + let _ = trace_float(" float from const 1:", &FLOAT_ONE); + let _ = trace_float(" float from const -1:", &FLOAT_NEGATIVE_ONE); +} + +fn test_float_compare() { + let _ = trace("\n$$$ test_float_compare $$$"); + + let mut f1: [u8; 8] = [0u8; 8]; + if 8 != unsafe { float_from_int(1, f1.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) } { + let _ = trace(" float from 1: failed"); + } else { + let _ = trace_float(" float from 1:", &f1); + } + + if 0 == unsafe { float_compare(f1.as_ptr(), 8, FLOAT_ONE.as_ptr(), 8) } { + let _ = trace(" float from 1 == FLOAT_ONE"); + } else { + let _ = trace(" float from 1 != FLOAT_ONE"); + } + + if 1 == unsafe { float_compare(f1.as_ptr(), 8, FLOAT_NEGATIVE_ONE.as_ptr(), 8) } { + let _ = trace(" float from 1 > FLOAT_NEGATIVE_ONE"); + } else { + let _ = trace(" float from 1 !> FLOAT_NEGATIVE_ONE"); + } + + if 2 == unsafe { float_compare(FLOAT_NEGATIVE_ONE.as_ptr(), 8, f1.as_ptr(), 8) } { + let _ = trace(" FLOAT_NEGATIVE_ONE < float from 1"); + } else { + let _ = trace(" FLOAT_NEGATIVE_ONE !< float from 1"); + } +} + +fn test_float_add_subtract() { + let _ = trace("\n$$$ test_float_add_subtract $$$"); + + let mut f_compute: [u8; 8] = FLOAT_ONE; + for i in 0..9 { + unsafe { + float_add( + f_compute.as_ptr(), + 8, + FLOAT_ONE.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + // let _ = trace_float(" float:", &f_compute); + } + let mut f10: [u8; 8] = [0u8; 8]; + if 8 != unsafe { float_from_int(10, f10.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) } { + // let _ = trace(" float from 10: failed"); + } + if 0 == unsafe { float_compare(f10.as_ptr(), 8, f_compute.as_ptr(), 8) } { + let _ = trace(" repeated add: good"); + } else { + let _ = trace(" repeated add: bad"); + } + + for i in 0..11 { + unsafe { + float_subtract( + f_compute.as_ptr(), + 8, + FLOAT_ONE.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + } + if 0 == unsafe { float_compare(f_compute.as_ptr(), 8, FLOAT_NEGATIVE_ONE.as_ptr(), 8) } { + let _ = trace(" repeated subtract: good"); + } else { + let _ = trace(" repeated subtract: bad"); + } +} + +fn test_float_multiply_divide() { + let _ = trace("\n$$$ test_float_multiply_divide $$$"); + + let mut f10: [u8; 8] = [0u8; 8]; + unsafe { float_from_int(10, f10.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) }; + let mut f_compute: [u8; 8] = FLOAT_ONE; + for i in 0..6 { + unsafe { + float_multiply( + f_compute.as_ptr(), + 8, + f10.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + // let _ = trace_float(" float:", &f_compute); + } + let mut f1000000: [u8; 8] = [0u8; 8]; + unsafe { + float_from_int( + 1000000, + f1000000.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + + if 0 == unsafe { float_compare(f1000000.as_ptr(), 8, f_compute.as_ptr(), 8) } { + let _ = trace(" repeated multiply: good"); + } else { + let _ = trace(" repeated multiply: bad"); + } + + for i in 0..7 { + unsafe { + float_divide( + f_compute.as_ptr(), + 8, + f10.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + } + let mut f01: [u8; 8] = [0u8; 8]; + unsafe { float_set(-1, 1, f01.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) }; + + if 0 == unsafe { float_compare(f_compute.as_ptr(), 8, f01.as_ptr(), 8) } { + let _ = trace(" repeated divide: good"); + } else { + let _ = trace(" repeated divide: bad"); + } +} + +fn test_float_pow() { + let _ = trace("\n$$$ test_float_pow $$$"); + + let mut f_compute: [u8; 8] = [0u8; 8]; + unsafe { + float_pow( + FLOAT_ONE.as_ptr(), + 8, + 3, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float cube of 1:", &f_compute); + + unsafe { + float_pow( + FLOAT_NEGATIVE_ONE.as_ptr(), + 8, + 6, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float 6th power of -1:", &f_compute); + + let mut f9: [u8; 8] = [0u8; 8]; + unsafe { float_from_int(9, f9.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) }; + unsafe { + float_pow( + f9.as_ptr(), + 8, + 2, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float square of 9:", &f_compute); + + unsafe { + float_pow( + f9.as_ptr(), + 8, + 0, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float 0th power of 9:", &f_compute); + + let mut f0: [u8; 8] = [0u8; 8]; + unsafe { float_from_int(0, f0.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) }; + unsafe { + float_pow( + f0.as_ptr(), + 8, + 2, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float square of 0:", &f_compute); + + let r = unsafe { + float_pow( + f0.as_ptr(), + 8, + 0, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_num( + " float 0th power of 0 (expecting INVALID_PARAMS error):", + r as i64, + ); +} + +fn test_float_root() { + let _ = trace("\n$$$ test_float_root $$$"); + + let mut f9: [u8; 8] = [0u8; 8]; + unsafe { float_from_int(9, f9.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) }; + let mut f_compute: [u8; 8] = [0u8; 8]; + unsafe { + float_root( + f9.as_ptr(), + 8, + 2, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float sqrt of 9:", &f_compute); + unsafe { + float_root( + f9.as_ptr(), + 8, + 3, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float cbrt of 9:", &f_compute); + + let mut f1000000: [u8; 8] = [0u8; 8]; + unsafe { + float_from_int( + 1000000, + f1000000.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + unsafe { + float_root( + f1000000.as_ptr(), + 8, + 3, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float cbrt of 1000000:", &f_compute); + unsafe { + float_root( + f1000000.as_ptr(), + 8, + 6, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" float 6th root of 1000000:", &f_compute); +} + +fn test_float_log() { + let _ = trace("\n$$$ test_float_log $$$"); + + let mut f1000000: [u8; 8] = [0u8; 8]; + unsafe { + float_from_int( + 1000000, + f1000000.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let mut f_compute: [u8; 8] = [0u8; 8]; + unsafe { + float_log( + f1000000.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" log_10 of 1000000:", &f_compute); +} + +fn test_float_negate() { + let _ = trace("\n$$$ test_float_negate $$$"); + + let mut f_compute: [u8; 8] = [0u8; 8]; + unsafe { + float_multiply( + FLOAT_ONE.as_ptr(), + 8, + FLOAT_NEGATIVE_ONE.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + // let _ = trace_float(" float:", &f_compute); + if 0 == unsafe { float_compare(FLOAT_NEGATIVE_ONE.as_ptr(), 8, f_compute.as_ptr(), 8) } { + let _ = trace(" negate const 1: good"); + } else { + let _ = trace(" negate const 1: bad"); + } + + unsafe { + float_multiply( + FLOAT_NEGATIVE_ONE.as_ptr(), + 8, + FLOAT_NEGATIVE_ONE.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + // let _ = trace_float(" float:", &f_compute); + if 0 == unsafe { float_compare(FLOAT_ONE.as_ptr(), 8, f_compute.as_ptr(), 8) } { + let _ = trace(" negate const -1: good"); + } else { + let _ = trace(" negate const -1: bad"); + } +} + +fn test_float_invert() { + let _ = trace("\n$$$ test_float_invert $$$"); + + let mut f_compute: [u8; 8] = [0u8; 8]; + let mut f10: [u8; 8] = [0u8; 8]; + unsafe { float_from_int(10, f10.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) }; + unsafe { + float_divide( + FLOAT_ONE.as_ptr(), + 8, + f10.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" invert a float from 10:", &f_compute); + unsafe { + float_divide( + FLOAT_ONE.as_ptr(), + 8, + f_compute.as_ptr(), + 8, + f_compute.as_mut_ptr(), + 8, + FLOAT_ROUNDING_MODES_TO_NEAREST, + ) + }; + let _ = trace_float(" invert again:", &f_compute); + + // if f10's value is 7, then invert twice won't match the original value + if 0 == unsafe { float_compare(f10.as_ptr(), 8, f_compute.as_ptr(), 8) } { + let _ = trace(" invert twice: good"); + } else { + let _ = trace(" invert twice: bad"); + } +} + +#[unsafe(no_mangle)] +pub extern "C" fn finish() -> i32 { + test_float_from_wasm(); + test_float_compare(); + test_float_add_subtract(); + test_float_multiply_divide(); + test_float_pow(); + test_float_root(); + test_float_log(); + test_float_negate(); + test_float_invert(); + + 1 +} diff --git a/src/test/app/wasm_fixtures/ledgerSqn.c b/src/test/app/wasm_fixtures/ledgerSqn.c new file mode 100644 index 0000000000..66ed1d42c7 --- /dev/null +++ b/src/test/app/wasm_fixtures/ledgerSqn.c @@ -0,0 +1,27 @@ +#include + +int32_t +get_ledger_sqn(uint8_t*, int32_t); +// int32_t trace(uint8_t const*, int32_t, uint8_t const*, int32_t, int32_t); +// int32_t trace_num(uint8_t const*, int32_t, int64_t); + +uint8_t buf[1024]; + +// char const test_res[] = "sqn: "; +// char const test_name[] = "TEST get_ledger_sqn"; + +int +finish() +{ + // trace((uint8_t const *)test_name, sizeof(test_name) - 1, 0, 0, 0); + + // memset(buf, 0, sizeof(buf)); + // for(int i = 0; i < sizeof(buf); ++i) buf[i] = 0; + + int x = get_ledger_sqn(buf, sizeof(int32_t)); + if (x >= 0) + x = *((int32_t*)buf); + // trace_num((uint8_t const *)test_res, sizeof(test_res) - 1, x); + + return x < 0 ? x : (x >= 5 ? 1 : 0); +} diff --git a/src/test/app/wasm_fixtures/sha512Pure.c b/src/test/app/wasm_fixtures/sha512Pure.c new file mode 100644 index 0000000000..fe82aa2a65 --- /dev/null +++ b/src/test/app/wasm_fixtures/sha512Pure.c @@ -0,0 +1,145 @@ +#include +#include + +static uint64_t const K512[] = { + 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, + 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019, + 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, + 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, + 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, + 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275, + 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, + 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, + 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, + 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, + 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, + 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, + 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001, + 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, + 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, + 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, + 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, + 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, + 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, + 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207, + 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, + 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, + 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, + 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, + 0x5fcb6fab3ad6faec, 0x6c44198c4a475817}; + +#define ROTATE(x, y) (((x) >> (y)) | ((x) << (64 - (y)))) +#define Sigma0(x) (ROTATE((x), 28) ^ ROTATE((x), 34) ^ ROTATE((x), 39)) +#define Sigma1(x) (ROTATE((x), 14) ^ ROTATE((x), 18) ^ ROTATE((x), 41)) +#define sigma0(x) (ROTATE((x), 1) ^ ROTATE((x), 8) ^ ((x) >> 7)) +#define sigma1(x) (ROTATE((x), 19) ^ ROTATE((x), 61) ^ ((x) >> 6)) + +#define Ch(x, y, z) (((x) & (y)) ^ ((~(x)) & (z))) +#define Maj(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) + +static inline uint64_t +B2U64(uint8_t val, uint8_t sh) +{ + return ((uint64_t)val) << sh; +} + +void* +allocate(int sz) +{ + return malloc(sz); +} +void +deallocate(void* p) +{ + free(p); +} + +uint8_t e_data[32 * 1024]; + +uint8_t* +sha512_process(uint8_t const* data, int32_t length) +{ + static uint64_t state[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + + uint64_t a, b, c, d, e, f, g, h, s0, s1, T1, T2; + uint64_t X[16]; + + uint64_t blocks = length / 128; + while (blocks--) + { + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + f = state[5]; + g = state[6]; + h = state[7]; + + unsigned i; + for (i = 0; i < 16; i++) + { + X[i] = B2U64(data[0], 56) | B2U64(data[1], 48) | + B2U64(data[2], 40) | B2U64(data[3], 32) | B2U64(data[4], 24) | + B2U64(data[5], 16) | B2U64(data[6], 8) | B2U64(data[7], 0); + data += 8; + + T1 = h; + T1 += Sigma1(e); + T1 += Ch(e, f, g); + T1 += K512[i]; + T1 += X[i]; + + T2 = Sigma0(a); + T2 += Maj(a, b, c); + + h = g; + g = f; + f = e; + e = d + T1; + d = c; + c = b; + b = a; + a = T1 + T2; + } + + for (i = 16; i < 80; i++) + { + s0 = X[(i + 1) & 0x0f]; + s0 = sigma0(s0); + s1 = X[(i + 14) & 0x0f]; + s1 = sigma1(s1); + + T1 = X[i & 0xf] += s0 + s1 + X[(i + 9) & 0xf]; + T1 += h + Sigma1(e) + Ch(e, f, g) + K512[i]; + T2 = Sigma0(a) + Maj(a, b, c); + + h = g; + g = f; + f = e; + e = d + T1; + d = c; + c = b; + b = a; + a = T1 + T2; + } + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + state[5] += f; + state[6] += g; + state[7] += h; + } + + return (uint8_t*)(state); +} + +// int main () +//{ +// return 0; +// } diff --git a/src/test/app/wasm_fixtures/sp1/Cargo.lock b/src/test/app/wasm_fixtures/sp1/Cargo.lock new file mode 100644 index 0000000000..4374624cd2 --- /dev/null +++ b/src/test/app/wasm_fixtures/sp1/Cargo.lock @@ -0,0 +1,1384 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "android-tzdata" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anstream" +version = "0.6.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd" + +[[package]] +name = "anstyle-parse" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2" +dependencies = [ + "windows-sys 0.60.2", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys 0.60.2", +] + +[[package]] +name = "anyhow" +version = "1.0.98" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487" + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "base16ct" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" + +[[package]] +name = "bincode" +version = "1.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" +dependencies = [ + "serde", +] + +[[package]] +name = "bitflags" +version = "2.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" + +[[package]] +name = "blake3" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0" +dependencies = [ + "arrayref", + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "bumpalo" +version = "3.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" + +[[package]] +name = "bytemuck" +version = "1.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c76a5792e44e4abe34d3abf15636779261d45a7450612059293d1d2cfc63422" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f154e572231cb6ba2bd1176980827e3d5dc04cc183a75dea38109fbdd672d29" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "camino" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0da45bc31171d8d6960122e222a67740df867c1dd53b4d51caa297084c185cab" +dependencies = [ + "serde", +] + +[[package]] +name = "cargo-platform" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea" +dependencies = [ + "serde", +] + +[[package]] +name = "cargo_metadata" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037" +dependencies = [ + "camino", + "cargo-platform", + "semver", + "serde", + "serde_json", + "thiserror 1.0.69", +] + +[[package]] +name = "cc" +version = "1.2.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3a42d84bb6b69d3a8b3eaacf0d88f179e1929695e1ad012b6cf64d9caaa5fd2" +dependencies = [ + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" + +[[package]] +name = "chrono" +version = "0.4.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d" +dependencies = [ + "android-tzdata", + "iana-time-zone", + "num-traits", + "windows-link", +] + +[[package]] +name = "clap" +version = "4.5.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50fd97c9dc2399518aa331917ac6f274280ec5eb34e555dd291899745c48ec6f" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.5.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c35b5830294e1fa0462034af85cc95225a4cb07092c088c55bda3147cfcd8f65" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_derive" +version = "4.5.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "clap_lex" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675" + +[[package]] +name = "colorchoice" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" + +[[package]] +name = "const-oid" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" + +[[package]] +name = "constant_time_eq" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6" + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-bigint" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" +dependencies = [ + "generic-array", + "rand_core", + "subtle", + "zeroize", +] + +[[package]] +name = "crypto-common" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "der" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" +dependencies = [ + "const-oid", + "zeroize", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", + "subtle", +] + +[[package]] +name = "dirs" +version = "5.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c" +dependencies = [ + "libc", + "option-ext", + "redox_users", + "windows-sys 0.48.0", +] + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "elliptic-curve" +version = "0.13.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" +dependencies = [ + "base16ct", + "crypto-bigint", + "digest", + "ff", + "generic-array", + "group", + "hkdf", + "rand_core", + "sec1", + "subtle", + "zeroize", +] + +[[package]] +name = "ff" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" +dependencies = [ + "rand_core", + "subtle", +] + +[[package]] +name = "gcd" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d758ba1b47b00caf47f24925c0074ecb20d6dfcffe7f6d53395c0465674841a" + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", + "zeroize", +] + +[[package]] +name = "getrandom" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core", + "subtle", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hkdf" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7" +dependencies = [ + "hmac", +] + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" + +[[package]] +name = "itertools" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" + +[[package]] +name = "js-sys" +version = "0.3.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +dependencies = [ + "spin", +] + +[[package]] +name = "libc" +version = "0.2.174" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776" + +[[package]] +name = "libredox" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "391290121bad3d37fbddad76d8f5d1c1c314cfc646d143d7e07a3086ddff0ce3" +dependencies = [ + "bitflags", + "libc", +] + +[[package]] +name = "log" +version = "0.4.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" + +[[package]] +name = "memchr" +version = "2.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" + +[[package]] +name = "num-bigint" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad" + +[[package]] +name = "option-ext" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" + +[[package]] +name = "p3-baby-bear" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49ecc3edc6fb8186268e05031c26a8b2b1e567957d63adcae1026d55d6bb189b" +dependencies = [ + "num-bigint", + "p3-field", + "p3-mds", + "p3-poseidon2", + "p3-symmetric", + "rand", + "serde", +] + +[[package]] +name = "p3-dft" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eece7b035978976138622b116fefe6c4cc372b1ce70739c40e7a351a9bb68f1f" +dependencies = [ + "p3-field", + "p3-matrix", + "p3-maybe-rayon", + "p3-util", + "tracing", +] + +[[package]] +name = "p3-field" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f0edf3fde4fd0d1455e901fc871c558010ae18db6e68f1b0fa111391855316" +dependencies = [ + "itertools", + "num-bigint", + "num-traits", + "p3-util", + "rand", + "serde", +] + +[[package]] +name = "p3-matrix" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60961b4d7ffd2e8412ce4e66e213de610356df71cc4e396519c856a664138a27" +dependencies = [ + "itertools", + "p3-field", + "p3-maybe-rayon", + "p3-util", + "rand", + "serde", + "tracing", +] + +[[package]] +name = "p3-maybe-rayon" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bbe762738c382c9483410f52348ab9de41bb42c391e8171643a71486cf1ef8f" + +[[package]] +name = "p3-mds" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4127956cc6c783b7d021c5c42d5d89456d5f3bda4a7b165fcc2a3fd4e78fbede" +dependencies = [ + "itertools", + "p3-dft", + "p3-field", + "p3-matrix", + "p3-symmetric", + "p3-util", + "rand", +] + +[[package]] +name = "p3-poseidon2" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be09497da406a98e89dc05c1ce539eeef29541bad61a5b2108a44ffe94dd0b4c" +dependencies = [ + "gcd", + "p3-field", + "p3-mds", + "p3-symmetric", + "rand", + "serde", +] + +[[package]] +name = "p3-symmetric" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e7d954033f657d48490344ca4b3dbcc054962a0e92831b736666bb2f5e5820b" +dependencies = [ + "itertools", + "p3-field", + "serde", +] + +[[package]] +name = "p3-util" +version = "0.2.2-succinct" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a6ce0b6bee23fd54e05306f6752ae80b0b71a91166553ab39d7899801497237" +dependencies = [ + "serde", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "proc-macro2" +version = "1.0.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "redox_users" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43" +dependencies = [ + "getrandom", + "libredox", + "thiserror 1.0.69", +] + +[[package]] +name = "rustc-hex" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6" + +[[package]] +name = "rustversion" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d" + +[[package]] +name = "ryu" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" + +[[package]] +name = "sec1" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +dependencies = [ + "base16ct", + "der", + "generic-array", + "subtle", + "zeroize", +] + +[[package]] +name = "semver" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0" +dependencies = [ + "serde", +] + +[[package]] +name = "serde" +version = "1.0.219" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.219" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.142" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7" +dependencies = [ + "itoa", + "memchr", + "ryu", + "serde", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "sp1" +version = "0.0.1" +dependencies = [ + "sp1-verifier", +] + +[[package]] +name = "sp1-build" +version = "4.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05372b4e3eecca255ba8e385f8dc294861a3b4ea0b0a9946873e39941011db4c" +dependencies = [ + "anyhow", + "cargo_metadata", + "chrono", + "clap", + "dirs", +] + +[[package]] +name = "sp1-lib" +version = "4.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e166e94b13146c65de433cf29acc1030f021414fbebfc24cd4eeaeb787ba3443" +dependencies = [ + "bincode", + "elliptic-curve", + "serde", + "sp1-primitives", +] + +[[package]] +name = "sp1-primitives" +version = "4.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a85ffe9606bd2cc93575ce608f063ca08521cee9bdebf611914c5b2d90d7412" +dependencies = [ + "bincode", + "blake3", + "cfg-if", + "hex", + "lazy_static", + "num-bigint", + "p3-baby-bear", + "p3-field", + "p3-poseidon2", + "p3-symmetric", + "serde", + "sha2", +] + +[[package]] +name = "sp1-verifier" +version = "4.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d94a7db4a54984acf4d64c6ba55c4698104f02ef213cc21882e233b4409e7155" +dependencies = [ + "blake3", + "cfg-if", + "hex", + "lazy_static", + "sha2", + "sp1-build", + "substrate-bn-succinct", + "thiserror 2.0.12", +] + +[[package]] +name = "spin" +version = "0.9.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "substrate-bn-succinct" +version = "0.6.0-v4.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ac8ce0a40e721f790e2ef99beab32b99b3121c58edaaa140ffd8f1795a6af7" +dependencies = [ + "bytemuck", + "byteorder", + "cfg-if", + "crunchy", + "lazy_static", + "num-bigint", + "rand", + "rustc-hex", + "sp1-lib", +] + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708" +dependencies = [ + "thiserror-impl 2.0.12", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing" +version = "0.1.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing-core" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678" +dependencies = [ + "once_cell", +] + +[[package]] +name = "typenum" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f" + +[[package]] +name = "unicode-ident" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasm-bindgen" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6" +dependencies = [ + "bumpalo", + "log", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "windows-core" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.60.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" + +[[package]] +name = "windows-result" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.3", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.53.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.0", + "windows_aarch64_msvc 0.53.0", + "windows_i686_gnu 0.53.0", + "windows_i686_gnullvm", + "windows_i686_msvc 0.53.0", + "windows_x86_64_gnu 0.53.0", + "windows_x86_64_gnullvm 0.53.0", + "windows_x86_64_msvc 0.53.0", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486" + +[[package]] +name = "zerocopy" +version = "0.8.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zeroize" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" diff --git a/src/test/app/wasm_fixtures/sp1/Cargo.toml b/src/test/app/wasm_fixtures/sp1/Cargo.toml new file mode 100644 index 0000000000..d730160aea --- /dev/null +++ b/src/test/app/wasm_fixtures/sp1/Cargo.toml @@ -0,0 +1,16 @@ +[package] +edition = "2021" +name = "sp1" +version = "0.0.1" + +[lib] +crate-type = ["cdylib"] + +[dependencies] +sp1-verifier = "4.1.3" + +[profile.release] +opt-level = 3 # "z" for size or "3" for speed +lto = true # Link Time Optimization +codegen-units = 1 # Single unit = better optimization +panic = "abort" # Smaller binary, faster execution diff --git a/src/test/app/wasm_fixtures/sp1/src/lib.rs b/src/test/app/wasm_fixtures/sp1/src/lib.rs new file mode 100644 index 0000000000..f918e4f42d --- /dev/null +++ b/src/test/app/wasm_fixtures/sp1/src/lib.rs @@ -0,0 +1,37 @@ +use sp1_verifier::Groth16Verifier; + +#[no_mangle] +pub fn sp1_groth16_verifier() -> bool { + let groth16_vk = *sp1_verifier::GROTH16_VK_BYTES; + + let proof: Vec = vec![ + 17, 182, 160, 157, 31, 189, 116, 200, 17, 224, 230, 34, 195, 108, 230, 185, 62, 91, 181, + 212, 80, 111, 197, 89, 247, 206, 99, 206, 147, 13, 216, 101, 252, 192, 149, 2, 40, 4, 249, + 44, 97, 227, 127, 36, 244, 18, 27, 75, 248, 3, 45, 11, 103, 45, 183, 204, 61, 217, 19, 208, + 66, 73, 202, 108, 136, 162, 221, 184, 6, 189, 49, 196, 104, 128, 151, 21, 104, 109, 145, + 150, 243, 51, 27, 243, 203, 75, 176, 59, 193, 51, 177, 64, 83, 13, 133, 140, 248, 242, 13, + 24, 12, 103, 126, 112, 244, 181, 129, 246, 52, 110, 134, 57, 149, 23, 163, 43, 202, 7, 164, + 233, 179, 160, 16, 5, 22, 45, 129, 76, 183, 76, 150, 139, 27, 224, 191, 59, 47, 105, 71, + 47, 8, 176, 157, 159, 234, 253, 239, 131, 138, 120, 101, 4, 98, 236, 106, 235, 98, 76, 93, + 220, 174, 153, 58, 216, 28, 141, 129, 191, 188, 40, 184, 225, 22, 61, 75, 139, 159, 162, + 117, 83, 214, 239, 1, 246, 236, 255, 64, 228, 116, 107, 206, 23, 59, 3, 221, 95, 14, 170, + 28, 171, 36, 179, 75, 101, 177, 40, 198, 12, 193, 82, 105, 155, 177, 62, 158, 72, 209, 252, + 51, 169, 109, 32, 121, 179, 194, 73, 164, 14, 8, 206, 181, 9, 5, 38, 74, 136, 97, 0, 89, + 80, 75, 88, 228, 94, 46, 196, 199, 83, 229, 11, 103, 115, 25, 31, 215, 137, 65, 159, 95, + 192, + ]; + + let sp1_public_values = vec![ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 8, + ]; + + let sp1_vkey_hash: String = + "0x00aea8e9c83c73d74036923de1b4a66d18547d58eee4eacfee70235ed291954c".to_string(); + + let _ = Groth16Verifier::verify(&proof, &sp1_public_values, &sp1_vkey_hash, groth16_vk); + + true +} diff --git a/src/test/app/wasm_fixtures/zk_proof/Cargo.lock b/src/test/app/wasm_fixtures/zk_proof/Cargo.lock new file mode 100644 index 0000000000..f042837723 --- /dev/null +++ b/src/test/app/wasm_fixtures/zk_proof/Cargo.lock @@ -0,0 +1,106 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "bitvec" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c" +dependencies = [ + "funty", + "radium", + "tap", + "wyz", +] + +[[package]] +name = "bls12_381" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7bc6d6292be3a19e6379786dac800f551e5865a5bb51ebbe3064ab80433f403" +dependencies = [ + "ff", + "group", + "pairing", + "rand_core", + "subtle", +] + +[[package]] +name = "ff" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" +dependencies = [ + "bitvec", + "rand_core", + "subtle", +] + +[[package]] +name = "funty" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" + +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core", + "subtle", +] + +[[package]] +name = "pairing" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81fec4625e73cf41ef4bb6846cafa6d44736525f442ba45e407c4a000a13996f" +dependencies = [ + "group", +] + +[[package]] +name = "radium" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "tap" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" + +[[package]] +name = "wyz" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" +dependencies = [ + "tap", +] + +[[package]] +name = "zk_proof" +version = "0.0.1" +dependencies = [ + "bls12_381", + "group", +] diff --git a/src/test/app/wasm_fixtures/zk_proof/Cargo.toml b/src/test/app/wasm_fixtures/zk_proof/Cargo.toml new file mode 100644 index 0000000000..3e556d4317 --- /dev/null +++ b/src/test/app/wasm_fixtures/zk_proof/Cargo.toml @@ -0,0 +1,19 @@ +[package] +edition = "2021" +name = "zk_proof" +version = "0.0.1" + +[lib] +crate-type = ["cdylib"] + +[dependencies] +# bellman = "=0.14.0" +bls12_381 = "=0.8.0" +group = "0.13.0" + +[profile.release] +# opt-level = 3 # Optimize for time +opt-level = "z" # Optimize for size +lto = true # Enable Link Time Optimization +codegen-units = 1 +panic = "abort" # Remove unnecessary panic machinery diff --git a/src/test/app/wasm_fixtures/zk_proof/src/lib.rs b/src/test/app/wasm_fixtures/zk_proof/src/lib.rs new file mode 100644 index 0000000000..4d44d8e342 --- /dev/null +++ b/src/test/app/wasm_fixtures/zk_proof/src/lib.rs @@ -0,0 +1,254 @@ +use bls12_381::multi_miller_loop; +use bls12_381::Scalar; +use bls12_381::{G1Affine, G2Affine, G2Prepared}; +use group::prime::PrimeCurveAffine; +use group::Curve; + +use std::mem; +use std::os::raw::c_void; +// use std::time::{Instant}; + +// Groth16 proof struct +pub struct Proof { + pub a: G1Affine, + pub b: G2Affine, + pub c: G1Affine, +} + +// Groth16 verification key struct +pub struct VerifyingKey { + pub alpha_g1: G1Affine, + pub beta_g1: G1Affine, + pub beta_g2: G2Affine, + pub gamma_g2: G2Affine, + pub delta_g1: G1Affine, + pub delta_g2: G2Affine, + pub ic: Vec, +} + +#[no_mangle] +pub extern "C" fn allocate(size: usize) -> *mut c_void { + let mut buffer = Vec::with_capacity(size); + let pointer = buffer.as_mut_ptr(); + mem::forget(buffer); + pointer as *mut c_void + // } +} + +#[no_mangle] +fn deserialize_g1_wasm(buffer: &mut Vec) -> G1Affine { + let d_g1 = G1Affine::from_compressed(&buffer[0..48].try_into().unwrap()) + .expect("Failed to deserialize vk"); + + d_g1 +} + +fn deserialize_g2_wasm(buffer: &mut Vec) -> G2Affine { + let d_g2 = G2Affine::from_compressed(&buffer[0..96].try_into().unwrap()) + .expect("Failed to deserialize vk"); + + d_g2 +} + +#[no_mangle] +// pub extern fn bellman_groth16_test(pointer: *mut u8, capacity: usize) -> bool { +pub extern "C" fn bellman_groth16_test() -> bool { + // let mut bytes = Vec::new(); + // unsafe { + // // println!("Test in vm {:?}", pointer); + // let v = Vec::from_raw_parts(pointer, capacity, capacity); //TODO no need to deallocate?? + // bytes.extend_from_slice(&v); + // } + + // Hardcode the input bytes for testing in different WASM VMs + // let bytes = [172, 197, 81, 189, 121, 193, 159, 27, 92, 95, 151, 164, 40, 59, 214, 96, 132, 58, 87, 37, 169, 1, 63, 230, 35, 74, 245, 6, 185, 56, 120, 108, 214, 179, 187, 21, 36, 206, 43, 160, 10, 250, 249, 73, 210, 35, 137, 87, 177, 66, 65, 154, 11, 232, 137, 246, 125, 72, 227, 222, 116, 168, 87, 24, 165, 160, 132, 109, 108, 101, 222, 143, 78, 97, 48, 95, 59, 177, 29, 247, 219, 166, 73, 249, 69, 206, 15, 151, 30, 248, 235, 63, 148, 240, 17, 22, 150, 67, 252, 141, 95, 179, 94, 111, 207, 201, 192, 144, 154, 94, 21, 2, 22, 58, 96, 144, 227, 107, 107, 182, 142, 0, 57, 27, 168, 39, 226, 40, 163, 159, 112, 83, 196, 182, 215, 74, 92, 20, 158, 60, 23, 184, 198, 143, 17, 6, 242, 7, 75, 220, 87, 47, 224, 145, 99, 169, 203, 218, 112, 185, 51, 102, 59, 56, 171, 46, 49, 255, 116, 108, 241, 50, 180, 247, 62, 218, 181, 197, 155, 80, 61, 252, 8, 41, 232, 73, 51, 250, 223, 82, 94, 8, 185, 83, 223, 187, 6, 41, 20, 62, 189, 254, 11, 11, 58, 187, 200, 88, 53, 234, 98, 172, 213, 62, 22, 34, 90, 166, 182, 133, 8, 230, 103, 219, 233, 141, 10, 137, 210, 151, 4, 129, 29, 92, 103, 251, 72, 182, 162, 59, 20, 222, 188, 232, 13, 74, 214, 182, 172, 120, 33, 198, 57, 204, 134, 93, 26, 79, 213, 45, 146, 6, 128, 103, 63, 202, 226, 120, 141, 193, 248, 65, 196, 235, 21, 184, 104, 228, 206, 117, 190, 28, 153, 183, 68, 36, 63, 60, 131, 87, 137, 213, 105, 27, 110, 37, 238, 200, 250, 145, 76, 25, 57, 81, 69, 164, 208, 255, 49, 80, 14, 64, 181, 143, 12, 58, 35, 63, 199, 35, 70, 25, 86, 158, 210, 150, 59, 159, 253, 238, 174, 211, 142, 166, 223, 51, 134, 118, 171, 27, 218, 219, 117, 163, 71, 134, 95, 142, 83, 251, 240, 241, 162, 232, 93, 248, 167, 112, 197, 212, 169, 209, 159, 101, 140, 248, 222, 234, 201, 169, 76, 242, 7, 10, 192, 30, 151, 167, 74, 186, 97, 121, 144, 36, 6, 187, 92, 7, 248, 45, 134, 85, 240, 112, 74, 224, 70, 64, 198, 59, 26, 195, 192, 140, 101, 118, 175, 17, 160, 195, 142, 133, 1, 139, 5, 130, 245, 17, 73, 176, 232, 107, 130, 172, 110, 20, 190, 37, 108, 250, 178, 187, 151, 158, 35, 248, 246, 143, 38, 212, 133, 226, 24, 45, 33, 164, 46, 125, 200, 157, 253, 225, 132, 181, 60, 90, 7, 240, 80, 232, 97, 206, 164, 28, 12, 75, 68, 126, 230, 145, 216, 45, 180, 203, 19, 152, 29, 203, 9, 4, 145, 122, 206, 146, 179, 44, 145, 191, 126, 199, 175, 171, 127, 189, 222, 108, 126, 161, 80, 190, 47, 44, 8, 40, 65, 68, 95, 61, 109, 148, 175, 113, 226, 8, 93, 126, 53, 39, 192, 196, 6, 152, 194, 105, 169, 226, 192, 201, 184, 198, 134, 210, 153, 170, 12, 241, 90, 250, 233, 20, 152, 119, 142, 120, 83, 2, 164, 80, 178, 125, 227, 253, 207, 240, 201, 127, 213, 196, 100, 90, 65, 120, 50, 108, 175, 34, 192, 197, 173, 202, 176, 210, 131, 22, 216, 57, 169, 241, 28, 40, 44, 62, 11, 42, 50, 46, 204, 242, 109, 158, 114, 41, 127, 206, 25, 194, 255, 128, 245, 232, 193, 189, 229, 51, 93, 94, 64, 117, 33, 132, 75, 253, 114, 64, 116, 155, 183, 137, 112, 201, 243, 13, 221, 142, 164, 59, 98, 152, 249, 40, 133, 70, 185, 231, 249, 151, 253, 240, 122, 214, 60, 18, 132, 177, 37, 42, 75, 206, 12, 100, 214, 248, 234, 78, 165, 74, 212, 248, 32, 162, 254, 227, 218, 46, 9, 87, 0, 118, 13, 249, 107, 83, 5, 138, 223, 9, 247, 70, 160, 228, 197, 54, 87, 18, 1, 37, 199, 162, 84, 189, 161, 10, 26, 75, 45, 168, 185, 153, 245, 243, 51, 176, 208, 187, 235, 135, 239, 231, 42, 43, 233, 150, 46, 249, 73, 229, 138, 84, 89, 75, 129, 238, 211, 80, 147, 67, 159, 227, 214, 131, 188, 130, 70, 224, 1, 77, 139, 239, 185, 53, 68, 41, 193, 207, 16, 2, 33, 139, 214, 103, 240, 14, 141, 223, 24, 236, 50, 64, 79, 178, 6, 79, 38, 165, 35, 173, 203, 101, 3, 162, 49, 51, 4, 151, 127, 49, 47, 223, 244, 157, 229, 7, 88, 106, 141, 167, 183, 220, 15, 8, 119, 12, 82, 218, 14, 207, 0, 73, 27, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + let bytes = [ + 147, 235, 138, 182, 249, 146, 149, 28, 58, 36, 144, 99, 188, 155, 153, 135, 239, 79, 76, + 109, 152, 156, 202, 1, 153, 84, 239, 184, 69, 145, 133, 48, 156, 80, 122, 227, 231, 161, + 137, 232, 67, 183, 34, 186, 230, 135, 25, 90, 136, 201, 110, 134, 208, 93, 78, 82, 153, + 239, 208, 236, 160, 231, 192, 150, 215, 128, 193, 255, 107, 39, 133, 12, 136, 148, 119, 17, + 59, 198, 100, 49, 37, 89, 132, 205, 45, 79, 151, 112, 247, 140, 94, 179, 215, 165, 52, 182, + 153, 68, 204, 210, 218, 156, 69, 74, 192, 30, 160, 13, 80, 188, 23, 112, 21, 124, 91, 147, + 21, 140, 217, 226, 248, 60, 182, 119, 18, 34, 32, 41, 181, 128, 165, 97, 168, 76, 98, 44, + 114, 122, 128, 215, 68, 156, 18, 91, 5, 33, 22, 141, 249, 137, 49, 252, 82, 122, 206, 58, + 183, 108, 176, 15, 38, 183, 87, 254, 34, 102, 195, 78, 166, 227, 96, 180, 137, 173, 131, + 178, 179, 25, 89, 159, 5, 73, 125, 24, 25, 86, 227, 19, 184, 117, 228, 173, 150, 1, 82, + 142, 48, 251, 236, 132, 73, 79, 201, 165, 192, 191, 195, 60, 100, 198, 251, 187, 161, 220, + 63, 143, 38, 21, 189, 219, 194, 100, 64, 186, 102, 7, 186, 213, 227, 92, 228, 52, 181, 171, + 223, 222, 218, 206, 221, 22, 15, 46, 77, 175, 34, 43, 221, 110, 21, 89, 149, 213, 68, 242, + 140, 185, 176, 73, 88, 216, 75, 237, 209, 10, 75, 251, 152, 101, 15, 146, 168, 27, 81, 8, + 61, 76, 103, 230, 171, 23, 144, 171, 6, 118, 157, 233, 234, 214, 132, 106, 30, 171, 121, + 77, 147, 175, 170, 62, 48, 251, 12, 221, 202, 109, 80, 97, 180, 27, 45, 87, 162, 19, 168, + 152, 27, 205, 113, 91, 83, 52, 99, 109, 17, 149, 189, 244, 174, 164, 192, 79, 133, 111, + 195, 215, 232, 129, 166, 204, 3, 169, 248, 49, 18, 190, 198, 145, 177, 169, 10, 4, 66, 134, + 46, 11, 163, 170, 94, 230, 234, 234, 43, 122, 51, 230, 100, 106, 149, 228, 208, 217, 87, + 231, 125, 170, 47, 143, 151, 45, 208, 64, 91, 10, 188, 136, 15, 155, 131, 200, 141, 243, + 200, 5, 109, 22, 98, 189, 193, 44, 40, 95, 126, 145, 234, 190, 205, 179, 172, 224, 147, + 253, 238, 162, 157, 60, 126, 9, 174, 34, 16, 161, 197, 60, 243, 211, 241, 78, 114, 51, 167, + 214, 53, 149, 172, 56, 149, 32, 66, 123, 48, 240, 179, 53, 154, 29, 134, 34, 141, 204, 168, + 184, 158, 165, 115, 241, 119, 228, 11, 35, 82, 186, 132, 103, 65, 243, 215, 31, 105, 201, + 191, 155, 210, 53, 194, 76, 63, 199, 181, 28, 138, 181, 181, 211, 145, 15, 139, 244, 38, + 56, 159, 161, 95, 46, 147, 141, 163, 221, 88, 167, 134, 73, 45, 70, 98, 98, 167, 55, 52, + 234, 110, 150, 79, 248, 157, 167, 84, 210, 89, 10, 193, 169, 32, 40, 218, 7, 236, 206, 85, + 178, 174, 157, 132, 181, 192, 119, 60, 205, 46, 217, 120, 97, 59, 82, 121, 11, 189, 21, + 213, 176, 255, 225, 57, 76, 239, 38, 99, 226, 55, 98, 227, 10, 45, 193, 69, 255, 247, 39, + 121, 86, 150, 6, 220, 98, 41, 132, 237, 189, 169, 110, 213, 115, 33, 228, 197, 61, 219, + 202, 58, 54, 70, 223, 179, 208, 139, 232, 103, 76, 165, 169, 68, 6, 148, 47, 244, 26, 203, + 186, 110, 69, 44, 175, 128, 119, 212, 188, 167, 223, 87, 119, 238, 199, 201, 61, 78, 96, + 175, 0, 156, 145, 196, 253, 162, 175, 172, 227, 80, 251, 96, 61, 189, 35, 13, 97, 22, 157, + 86, 249, 128, 148, 172, 66, 80, 172, 208, 222, 131, 0, 207, 80, 163, 27, 155, 113, 57, 186, + 246, 139, 111, 71, 117, 152, 184, 60, 1, 230, 44, 169, 213, 88, 82, 156, 194, 234, 41, 183, + 87, 36, 175, 154, 156, 128, 59, 187, 208, 101, 9, 51, 205, 42, 174, 29, 215, 43, 150, 183, + 129, 125, 2, 84, 210, 149, 245, 126, 140, 166, 255, 134, 116, 162, 107, 82, 178, 158, 38, + 11, 135, 91, 224, 157, 112, 189, 164, 250, 1, 215, 49, 21, 214, 211, 73, 243, 251, 58, 198, + 1, 165, 196, 122, 13, 238, 252, 227, 229, 149, 47, 13, 173, 171, 176, 185, 220, 82, 96, + 163, 4, 36, 199, 152, 88, 3, 162, 49, 51, 4, 151, 127, 49, 47, 223, 244, 157, 229, 7, 88, + 106, 141, 167, 183, 220, 15, 8, 119, 12, 82, 218, 14, 207, 0, 73, 27, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ]; + + // ***** Test deserialization and reconstruction of vk ***** + // let start_key_recons = Instant::now(); + // println!("Start verification key reconstruction"); + + // alpha_g1 + let mut vec_alpha_g1 = bytes[0..48].to_vec(); + let r_alpha_g1 = deserialize_g1_wasm(&mut vec_alpha_g1); + + // beta_g1 + let mut vec_beta_g1 = bytes[48..96].to_vec(); + let r_beta_g1 = deserialize_g1_wasm(&mut vec_beta_g1); + + // beta_g2 + let mut vec_beta_g2 = bytes[96..192].to_vec(); + let r_beta_g2 = deserialize_g2_wasm(&mut vec_beta_g2); + + // gamma_g2 + let mut vec_gamma_g2 = bytes[192..288].to_vec(); + let r_gamma_g2 = deserialize_g2_wasm(&mut vec_gamma_g2); + + // delta_g1 + let mut vec_delta_g1 = bytes[288..336].to_vec(); + let r_delta_g1 = deserialize_g1_wasm(&mut vec_delta_g1); + + // delta_g2 + let mut vec_delta_g2 = bytes[336..432].to_vec(); + let r_delta_g2 = deserialize_g2_wasm(&mut vec_delta_g2); + + // ic + let vec_ic = bytes[432..576].to_vec(); + // println!("\nic vector: {:?}", vec_ic); + let mut r_ic: Vec = Vec::new(); + let mut vec_ic_de = vec_ic[0..48].to_vec(); + r_ic.push(deserialize_g1_wasm(&mut vec_ic_de)); + vec_ic_de = vec_ic[48..96].to_vec(); + r_ic.push(deserialize_g1_wasm(&mut vec_ic_de)); + vec_ic_de = vec_ic[96..144].to_vec(); + r_ic.push(deserialize_g1_wasm(&mut vec_ic_de)); + + // Reconstruct vk + // replace following if using bellman::{groth16, groth16::Proof}; + // let deserialized_vk = groth16::VerifyingKey:: { + let deserialized_vk = VerifyingKey { + alpha_g1: r_alpha_g1, + beta_g1: r_beta_g1, + beta_g2: r_beta_g2, + gamma_g2: r_gamma_g2, + delta_g1: r_delta_g1, + delta_g2: r_delta_g2, + ic: r_ic, + }; + + // Uncomment following if using bellman::{groth16, groth16::Proof}; + // let pvk = groth16::prepare_verifying_key(&deserialized_vk); + // println!("Key reconstruction time: {:?}", start_key_recons.elapsed()); + + // ***** Reconstruct proof ***** + // let start_proof_recons = Instant::now(); + + // proof.g1 + let r_a = G1Affine::from_compressed(&bytes[576..624].try_into().unwrap()) + .expect("Failed to deserialize a"); + // proof.g2 + let r_b = G2Affine::from_compressed(&bytes[624..720].try_into().unwrap()) + .expect("Failed to deserialize b"); + // proof.g1 + let r_c = G1Affine::from_compressed(&bytes[720..768].try_into().unwrap()) + .expect("Failed to deserialize c"); + + // Replace following if using bellman::{groth16, groth16::Proof}; + // let r_proof: Proof = Proof{a: r_a, b: r_b, c: r_c}; + let r_proof: Proof = Proof { + a: r_a, + b: r_b, + c: r_c, + }; + // println!("Proof reconstruction time: {:?}", start_proof_recons.elapsed()); + + // ***** Reconstruct input ***** + // let start_input_recons = Instant::now(); + + let last_64_bytes = &bytes[bytes.len() - 64..]; + + let r_inputs: Vec = last_64_bytes + .chunks(32) // Each Scalar in bls12_381 uses 32 bytes + .map(|chunk| { + Scalar::from_bytes(chunk.try_into().unwrap()).expect("Invalid bytes for Scalar") + }) + .collect(); + + // println!("Input reconstruction time: {:?}", start_input_recons.elapsed()); + + /***** proof verification *****/ + // uncomment following if bellman groth16 is used + // assert!(groth16::verify_proof(&pvk, &r_proof, &r_inputs).is_ok()); + // let start_verify = Instant::now(); + + // Ensure the number of inputs matches the vk.ic length minus 1 (for IC[0]) + if (r_inputs.len() + 1) != deserialized_vk.ic.len() { + return false; + } + + /***** Compute linear combination: input_acc = IC[0] + sum(input[i] * IC[i+1]) *****/ + let mut acc = deserialized_vk.ic[0].to_curve(); // Convert G1Affine to G1Projective + + // Computes multi-scalar multiplication, + // which is a weighted sum of elliptic curve points. + // In Groth16, this builds the point: + // acc = IC₀ + input₁ × IC₁ + input₂ × IC₂ + ... + inputₙ × ICₙ + // Where: ICᵢ are fixed elliptic curve points (from the verifying key). + // inputᵢ are the public inputs to the circuit. + // Example: public_inputs = [x₁, x₂], vk.ic = [IC₀, IC₁, IC₂], acc = IC₀ + x₁ * IC₁ + x₂ * IC₂ + // This binds the public inputs to the proof + for (input, ic_point) in r_inputs.iter().zip(&deserialized_vk.ic[1..]) { + acc += ic_point.to_curve() * input; + } + + let acc_affine = acc.to_affine(); // converts the point acc from projective form back to affine form. + + // Preparing G2 elements for pairing by converting them into G2Prepared format. + let proof_b_prepared = G2Prepared::from(r_proof.b); + let gamma_g2_prepared = G2Prepared::from(deserialized_vk.gamma_g2); + let delta_g2_prepared = G2Prepared::from(deserialized_vk.delta_g2); + let beta_g2_prepared = G2Prepared::from(deserialized_vk.beta_g2); + + // Compute required product of pairings in their Miller loop form + // Groth16 verifier checks if e(A, B) * e(acc, γ)⁻¹ * e(C, δ)⁻¹ * e(α, β)⁻¹ == 1 + // which boils down to + // let start_miller = Instant::now(); + let ml_result = multi_miller_loop(&[ + (&r_proof.a, &proof_b_prepared), // e(A,B) + (&(-acc_affine), &gamma_g2_prepared), // e(acc, γ)⁻¹ + (&(-r_proof.c), &delta_g2_prepared), // e(C, δ)⁻¹ + (&(-deserialized_vk.alpha_g1), &beta_g2_prepared), //e(α, β)⁻¹ + ]); + // println!("Miller time: {:?}", start_miller.elapsed()); + + // let start_final = Instant::now(); + let result = ml_result.final_exponentiation(); + // println!("Final time: {:?}", start_final.elapsed()); + // println!("Proof verification time: {:?}", start_verify.elapsed()); + + // true + result == bls12_381::Gt::identity() +} diff --git a/src/xrpld/app/wasm/detail/WamrVM.cpp b/src/xrpld/app/wasm/detail/WamrVM.cpp index d7cf9aa78d..413240559b 100644 --- a/src/xrpld/app/wasm/detail/WamrVM.cpp +++ b/src/xrpld/app/wasm/detail/WamrVM.cpp @@ -131,7 +131,7 @@ print_wasm_error(std::string_view msg, wasm_trap_t* trap, beast::Journal jlog) #ifdef DEBUG_OUTPUT auto& j = std::cerr; #else - auto j = jlog.error(); + auto j = jlog.warn(); #endif wasm_byte_vec_t error_message WASM_EMPTY_VEC; diff --git a/src/xrpld/app/wasm/detail/WasmVM.cpp b/src/xrpld/app/wasm/detail/WasmVM.cpp index 335d406254..6ea15f42ab 100644 --- a/src/xrpld/app/wasm/detail/WasmVM.cpp +++ b/src/xrpld/app/wasm/detail/WasmVM.cpp @@ -58,7 +58,6 @@ setCommonHostFunctions(HostFunctions* hfs, std::vector& i) WASM_IMPORT_FUNC2(i, getTxNestedArrayLen, "get_tx_nested_array_len", hfs, 70); WASM_IMPORT_FUNC2(i, getCurrentLedgerObjNestedArrayLen, "get_current_ledger_obj_nested_array_len", hfs, 70); WASM_IMPORT_FUNC2(i, getLedgerObjNestedArrayLen, "get_ledger_obj_nested_array_len", hfs, 70); - WASM_IMPORT_FUNC2(i, updateData, "update_data", hfs, 1000); WASM_IMPORT_FUNC2(i, checkSignature, "check_sig", hfs, 2000); WASM_IMPORT_FUNC2(i, computeSha512HalfHash, "compute_sha512_half", hfs, 2000); WASM_IMPORT_FUNC2(i, accountKeylet, "account_keylet", hfs, 350);