From 744522f3ca1fff112fa827400d7962da3fa52a90 Mon Sep 17 00:00:00 2001 From: cryptozoidberg Date: Sun, 29 Sep 2024 23:30:48 +0400 Subject: [PATCH 01/10] minor changes relatd to secp256k1_ecdsa integration --- .../include/serialization/keyvalue_helpers.h | 57 ++++++++++++++++++- src/crypto/eth_signature.cpp | 4 ++ src/crypto/eth_signature.h | 1 + src/currency_core/blockchain_storage.cpp | 10 +++- src/currency_core/currency_basic.h | 2 +- src/wallet/wallet2.cpp | 2 +- 6 files changed, 70 insertions(+), 6 deletions(-) diff --git a/contrib/epee/include/serialization/keyvalue_helpers.h b/contrib/epee/include/serialization/keyvalue_helpers.h index d76fc641..14997aa4 100644 --- a/contrib/epee/include/serialization/keyvalue_helpers.h +++ b/contrib/epee/include/serialization/keyvalue_helpers.h @@ -25,6 +25,8 @@ // #pragma once +#include +#include #include "misc_language.h" namespace epee { @@ -51,24 +53,73 @@ namespace epee } }; + template + struct is_std_optional : std::false_type {}; + + template + struct is_std_optional> : std::true_type {}; + + + template + struct is_std_optional> : std::true_type {}; + + + //basic helpers for pod-to-hex serialization + template + std::string transform_t_pod_to_str_internal(const t_pod_type& a) + { + return epee::string_tools::pod_to_hex(a); + } + + template + std::string transform_t_pod_to_str_internal(const std::optional& a) + { + if (a.has_value()) + return epee::string_tools::pod_to_hex(*a); + else + return ""; + } + + template + std::string transform_t_pod_to_str_internal(const boost::optional& a) + { + if (a.has_value()) + return epee::string_tools::pod_to_hex(*a); + else + return ""; + } //basic helpers for pod-to-hex serialization template std::string transform_t_pod_to_str(const t_pod_type & a) { - return epee::string_tools::pod_to_hex(a); + return transform_t_pod_to_str_internal(a); } - template + + + + template t_pod_type transform_str_to_t_pod(const std::string& a) { - t_pod_type res = AUTO_VAL_INIT(res); + t_pod_type res = AUTO_VAL_INIT(res); if (a.empty()) return res; + if constexpr (is_std_optional::value) + { + t_pod_type::value_type v = AUTO_VAL_INIT(v); + if (!epee::string_tools::hex_to_pod(a, v)) + throw std::runtime_error(std::string("Unable to transform \"") + a + "\" to pod type " + typeid(t_pod_type::value_type).name()); + return v; + } + + if (!epee::string_tools::hex_to_pod(a, res)) throw std::runtime_error(std::string("Unable to transform \"") + a + "\" to pod type " + typeid(t_pod_type).name()); return res; } + + //basic helpers for blob-to-hex serialization inline std::string transform_binbuf_to_hexstr(const std::string& a) diff --git a/src/crypto/eth_signature.cpp b/src/crypto/eth_signature.cpp index 0e33c47f..ba5b1358 100644 --- a/src/crypto/eth_signature.cpp +++ b/src/crypto/eth_signature.cpp @@ -157,6 +157,10 @@ namespace crypto { return o << epee::string_tools::pod_to_hex(v); } + std::ostream& operator<<(std::ostream& o, const eth_signature& v) + { + return o << epee::string_tools::pod_to_hex(v); + } } // namespace crypto diff --git a/src/crypto/eth_signature.h b/src/crypto/eth_signature.h index b186114a..b12d41fe 100644 --- a/src/crypto/eth_signature.h +++ b/src/crypto/eth_signature.h @@ -62,5 +62,6 @@ namespace crypto std::ostream& operator<<(std::ostream& o, const eth_secret_key& v); std::ostream& operator<<(std::ostream& o, const eth_public_key& v); + std::ostream& operator<<(std::ostream& o, const eth_signature& v); } // namespace crypto diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp index c05ffc53..6d4cbc1f 100644 --- a/src/currency_core/blockchain_storage.cpp +++ b/src/currency_core/blockchain_storage.cpp @@ -4116,7 +4116,15 @@ bool blockchain_storage::validate_ado_ownership(asset_op_verification_context& a asset_operation_ownership_proof_eth aoop_eth{}; r = get_type_in_variant_container(avc.tx.proofs, aoop_eth); CHECK_AND_ASSERT_MES(r, false, "Ownership validation failed: asset_operation_ownership_proof_eth is missing"); - return crypto::verify_eth_signature(avc.tx_id, last_ado.descriptor.owner_eth_pub_key.value(), aoop_eth.eth_sig); + if (!crypto::verify_eth_signature(avc.tx_id, last_ado.descriptor.owner_eth_pub_key.value(), aoop_eth.eth_sig)) + { + LOG_ERROR("Failed to validate secp256k1 signature for hash: " << avc.tx_id << ", signature: " << aoop_eth.eth_sig); + return false; + } + else + { + return true; + } } // owner_eth_pub_key has no value -- fallback to default } diff --git a/src/currency_core/currency_basic.h b/src/currency_core/currency_basic.h index 976207ad..c6581611 100644 --- a/src/currency_core/currency_basic.h +++ b/src/currency_core/currency_basic.h @@ -749,7 +749,7 @@ namespace currency KV_SERIALIZE(meta_info) DOC_DSCR("Any other information associated with the asset in free form.") DOC_EXMP("Stable and private") DOC_END KV_SERIALIZE_POD_AS_HEX_STRING(owner) DOC_DSCR("Owner's key, used only for EMIT and UPDATE validation, can be changed by transferring asset ownership.") DOC_EXMP("f74bb56a5b4fa562e679ccaadd697463498a66de4f1760b2cd40f11c3a00a7a8") DOC_END KV_SERIALIZE(hidden_supply) DOC_DSCR("This field is reserved for future use and will be documented later.") DOC_END - KV_SERIALIZE(owner_eth_pub_key) DOC_DSCR("[Optional] Owner's key in the case when ETH signature is used.") DOC_END + KV_SERIALIZE_POD_AS_HEX_STRING(owner_eth_pub_key) DOC_DSCR("[Optional] Owner's key in the case when ETH signature is used.") DOC_END END_KV_SERIALIZE_MAP() }; diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp index fb87bd2f..20745cdf 100644 --- a/src/wallet/wallet2.cpp +++ b/src/wallet/wallet2.cpp @@ -395,7 +395,7 @@ const crypto::public_key& wallet2::out_get_pub_key(const currency::tx_out_v& out void wallet2::process_ado_in_new_transaction(const currency::asset_descriptor_operation& ado, process_transaction_context& ptc) { auto print_ado_owner = [ado](std::ostream& o){ - ado.descriptor.owner_eth_pub_key.has_value() ? o << ado.descriptor.owner_eth_pub_key.get() << " (ETH)" : o << ado.descriptor.owner; + ado.descriptor.owner_eth_pub_key.has_value() ? o << ado.descriptor.owner_eth_pub_key.value() << " (ETH)" : o << ado.descriptor.owner; }; do From 27e310bb849eb2eb39cafc6f0aee0320a3d61f68 Mon Sep 17 00:00:00 2001 From: sowle Date: Mon, 30 Sep 2024 05:06:17 +0200 Subject: [PATCH 02/10] gcc compilation fixes --- contrib/epee/include/serialization/keyvalue_helpers.h | 4 ++-- tests/core_tests/tx_validation.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/contrib/epee/include/serialization/keyvalue_helpers.h b/contrib/epee/include/serialization/keyvalue_helpers.h index 14997aa4..ae72d4b3 100644 --- a/contrib/epee/include/serialization/keyvalue_helpers.h +++ b/contrib/epee/include/serialization/keyvalue_helpers.h @@ -106,9 +106,9 @@ namespace epee return res; if constexpr (is_std_optional::value) { - t_pod_type::value_type v = AUTO_VAL_INIT(v); + typename t_pod_type::value_type v = AUTO_VAL_INIT(v); if (!epee::string_tools::hex_to_pod(a, v)) - throw std::runtime_error(std::string("Unable to transform \"") + a + "\" to pod type " + typeid(t_pod_type::value_type).name()); + throw std::runtime_error(std::string("Unable to transform \"") + a + "\" to pod type " + typeid(typename t_pod_type::value_type).name()); return v; } diff --git a/tests/core_tests/tx_validation.cpp b/tests/core_tests/tx_validation.cpp index db6ae4ac..f82c3a10 100644 --- a/tests/core_tests/tx_validation.cpp +++ b/tests/core_tests/tx_validation.cpp @@ -9,7 +9,7 @@ #include "offers_tests_common.h" #include "tx_builder.h" #include "chaingen_helpers.h" -#include "..\..\src\currency_core\tx_semantic_validation.h" +#include "../../src/currency_core/tx_semantic_validation.h" using namespace epee; using namespace crypto; From d992a8bdc3d069e6ad3d5357b3bebfcca971803f Mon Sep 17 00:00:00 2001 From: cryptozoidberg Date: Mon, 30 Sep 2024 13:57:21 +0400 Subject: [PATCH 03/10] merged lates UI --- src/gui/qt-daemon/layout | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gui/qt-daemon/layout b/src/gui/qt-daemon/layout index 6d212d4e..5c878005 160000 --- a/src/gui/qt-daemon/layout +++ b/src/gui/qt-daemon/layout @@ -1 +1 @@ -Subproject commit 6d212d4eefaf6d13c72799cb89be2c80b1813d38 +Subproject commit 5c878005ace55484eafe2985d204cd51e90b203b From 890b3155b8222ea37f92165b414505115c118c4e Mon Sep 17 00:00:00 2001 From: zano build machine Date: Mon, 30 Sep 2024 13:00:02 +0300 Subject: [PATCH 04/10] === build number: 348 -> 349 === --- src/version.h.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/version.h.in b/src/version.h.in index 923f0c7c..9455b660 100644 --- a/src/version.h.in +++ b/src/version.h.in @@ -8,6 +8,6 @@ #define PROJECT_REVISION "1" #define PROJECT_VERSION PROJECT_MAJOR_VERSION "." PROJECT_MINOR_VERSION "." PROJECT_REVISION -#define PROJECT_VERSION_BUILD_NO 348 +#define PROJECT_VERSION_BUILD_NO 349 #define PROJECT_VERSION_BUILD_NO_STR STRINGIFY_EXPAND(PROJECT_VERSION_BUILD_NO) #define PROJECT_VERSION_LONG PROJECT_VERSION "." PROJECT_VERSION_BUILD_NO_STR "[" BUILD_COMMIT_ID "]" From 74b0e6d70fe325415cf1b21b92b1969079159256 Mon Sep 17 00:00:00 2001 From: cryptozoidberg Date: Tue, 1 Oct 2024 15:53:14 +0400 Subject: [PATCH 05/10] added secp256k1_ecdsa example in JS/ethers --- src/wallet/wallet_rpc_server.cpp | 2 +- utils/JS/.gitignore | 2 + utils/JS/decrypt_response.json | 77 +++++++++++ utils/JS/emmit_response.json | 25 ++++ utils/JS/package-lock.json | 192 ++++++++++++++++++++++++++ utils/JS/package.json | 6 + utils/JS/sign_response.json | 8 ++ utils/JS/test_eth_sig.js | 227 +++++++++++++++++++++++++++++++ 8 files changed, 538 insertions(+), 1 deletion(-) create mode 100644 utils/JS/.gitignore create mode 100644 utils/JS/decrypt_response.json create mode 100644 utils/JS/emmit_response.json create mode 100644 utils/JS/package-lock.json create mode 100644 utils/JS/package.json create mode 100644 utils/JS/sign_response.json create mode 100644 utils/JS/test_eth_sig.js diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp index d60fee98..1a372db9 100644 --- a/src/wallet/wallet_rpc_server.cpp +++ b/src/wallet/wallet_rpc_server.cpp @@ -1433,7 +1433,7 @@ namespace tools res.status = e.what(); return true; } - + res.status = API_RETURN_CODE_OK; return true; WALLET_RPC_CATCH_TRY_ENTRY(); } diff --git a/utils/JS/.gitignore b/utils/JS/.gitignore new file mode 100644 index 00000000..b8e83692 --- /dev/null +++ b/utils/JS/.gitignore @@ -0,0 +1,2 @@ +/node_modules* +.vscode \ No newline at end of file diff --git a/utils/JS/decrypt_response.json b/utils/JS/decrypt_response.json new file mode 100644 index 00000000..5082dfa0 --- /dev/null +++ b/utils/JS/decrypt_response.json @@ -0,0 +1,77 @@ +{ + "id": 0, + "jsonrpc": "2.0", + "result": { + "decoded_outputs": [ + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 464000000000, + "asset_id": "d6329b5b1f7c0805b5c345f4957554002a2f557845f64d7645dae0e051a6498a", + "out_index": 0 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 1 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 2 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 3 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 4 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 5 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 6 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 7 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 8 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 9 + }, + { + "address": "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "amount": 10000000000, + "asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "out_index": 10 + } + ], + "status": "OK", + "tx_in_json": "{
  "version": 2, 
  "vin": [ {
      "txin_zc_input": {
        "key_offsets": [ {
            "uint64_t": 196918
          }, {
            "uint64_t": 303308
          }, {
            "uint64_t": 15155
          }, {
            "uint64_t": 45175
          }, {
            "uint64_t": 11885
          }, {
            "uint64_t": 471
          }, {
            "uint64_t": 7357
          }, {
            "uint64_t": 482
          }, {
            "uint64_t": 4363
          }, {
            "uint64_t": 12039
          }, {
            "uint64_t": 156
          }, {
            "uint64_t": 162
          }, {
            "uint64_t": 255
          }, {
            "uint64_t": 47
          }, {
            "uint64_t": 565
          }, {
            "uint64_t": 342
          }
        ], 
        "k_image": "e3a5e8149b1dcef351249257586b076baf749ca95f16f3fc80fb32212e7f69d3", 
        "etc_details": [ ]
      }
    }], 
  "extra": [ {
      "asset_descriptor_base": , 
      "VERSION": 1, 
      "operation_type": 2, 
      "descriptor": , 
      "VERSION": 1, 
      "total_max_supply": 1000000000000000000, 
      "current_supply": 2000200000000000, 
      "decimal_point": 12, 
      "ticker": 4"5a414243", 
      "full_name": 16"5a616e6f207772617070656420414243", 
      "meta_info": 18"537461626c6520616e642070726976617465", 
      "owner": "0000000000000000000000000000000000000000000000000000000000000000", 
      "hidden_supply": "00", 
      "owner_eth_pub_key": "00""02657eb29026c3e07ba5935f2f52772d1a7d6631a5c359a0c343a856d5e7b73eb7", 
      "amount_commitment": "5623eb452b8df9727a721807232bc98493a14207e7dd2c87aedbbfef8691334b", 
      "opt_asset_id": "00""7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf"
    }, {
      "pub_key": "8a24bd502662321a4ae904cbad878967789ac186b3a6f194c4b0b9b9cc91a02f"
    }, {
      "etc_tx_flags16": , 
      "v": 0
    }, {
      "derivation_hint": , 
      "msg": 2"7307"
    }, {
      "derivation_hint": , 
      "msg": 2"4f38"
    }, {
      "derivation_hint": , 
      "msg": 2"593f"
    }, {
      "derivation_hint": , 
      "msg": 2"cd49"
    }, {
      "derivation_hint": , 
      "msg": 2"475a"
    }, {
      "derivation_hint": , 
      "msg": 2"33b3"
    }, {
      "derivation_hint": , 
      "msg": 2"4dba"
    }, {
      "derivation_hint": , 
      "msg": 2"70da"
    }, {
      "derivation_hint": , 
      "msg": 2"49de"
    }, {
      "derivation_hint": , 
      "msg": 2"50e6"
    }, {
      "derivation_hint": , 
      "msg": 2"37f4"
    }, {
      "zarcanum_tx_data_v1": {
        "fee": 10000000000
      }
    }
  ], 
  "vout": [ {
      "tx_out_zarcanum": {
        "stealth_address": "143cbed38fd2778857e119f95f190537bbf26ad48ef407b510ae355a48208bb4", 
        "concealing_point": "cb56b1909f159270f2497e8510fb878d67d28fcb5ca1d88ed51e98b839565d52", 
        "amount_commitment": "65bd8252610862b381fc761eeca7e880081540dad1bfb4b7ba7ce0b791c43109", 
        "blinded_asset_id": "3b4f1c2911a481fed6536d099cdae07b5b73d7a03066442825dd94cd9b166ca8", 
        "encrypted_amount": 13787803383471767883, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "827db228879fac73969647bdff8a3ce9bc803695cb82beb16e2a0db3c9886818", 
        "concealing_point": "f06840b98e12c4da8c95e41973120c018d648c73887eb8ab9ec140b3e3b690e5", 
        "amount_commitment": "d5655cc4a23790022019b2622c213596eae1e99295843c44bbbec4c91f70749a", 
        "blinded_asset_id": "5afbb9b958fe11a69807fc58fe9f28a0eaa8de829ae2044ef24e16fd72f2db22", 
        "encrypted_amount": 10459951052424769641, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "4784fa3c46b73995a78f976e25a9aad4fefaa562964ea4b33116a7ed7ac960eb", 
        "concealing_point": "80a51fee9b8fac8f3add49f3978ed40cac39c961a7092ea112c9dac12a996107", 
        "amount_commitment": "c53fe31ce70f6384d5bdc84daeb4fb6f7d841479ab2f5ab44e5a93f06c3b7088", 
        "blinded_asset_id": "200dc5c7ec2df4353e1f6acab9be1459a981d29bb9aad3a046c121891d84110d", 
        "encrypted_amount": 10903588260482129377, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "4ec19acd172e17cc5aa5c7cd9090a1108793a48252537fb1e18a52d640ff8455", 
        "concealing_point": "905a75d91c37830306f0c31ba7c995cb88afaf7512eac66bcf7fdd0a1248e904", 
        "amount_commitment": "114fc2249ce37698e2393e72bcca1ad822d349356c7cbd21901ce304467b4c63", 
        "blinded_asset_id": "e61ab1846e9b82aa7d6c71cef6c2dd326742ed82f5a48df4a534a74bac452354", 
        "encrypted_amount": 11561222210089138485, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "1d5453bf3f5ee6e6f17a7f244829db9f70552301e3694e7c9874cf1079cb2263", 
        "concealing_point": "86ddba4662e680afc28de8195d11d7e0263cf25c24cd137662418bf681d0a898", 
        "amount_commitment": "8d4573dc0646ec274c6aaaf3c6f64270e6714cbb7e4b991e50353aa42e74aab8", 
        "blinded_asset_id": "faad11832ec4e9e540844d54c94a1eb90faf8373c075dd7556212df65785308b", 
        "encrypted_amount": 3533589153034218094, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "e45acb5ecd141d5f90923015487f6f2351fcdd4cacd8bec86530549cd499a3dd", 
        "concealing_point": "18ad1b576d94829a7aa4ad8ed828a54a2852372a0d44d4e7c8a4d66d23ba4ca1", 
        "amount_commitment": "179690d25280d5239e803b1d42eeebb98e40384cbfc612f8cc742c961955b752", 
        "blinded_asset_id": "3185e4e39e25b80ae64590c1dfa088a88a3b932f08120786e0f71acdf78a18de", 
        "encrypted_amount": 7616934656027143448, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "5620b88edfc4060870334ac858faff194992a3f751ce4dbd9f8cbc625c3c9b5a", 
        "concealing_point": "96d69f9daed20aca13dd45b53e1b9c4a4c2310d1445aec046a72f82227468e5d", 
        "amount_commitment": "fc317e0c524788e60f6746244662400c2314f6d211af00876f3280fbb84b2a2f", 
        "blinded_asset_id": "f71b53d0e492080e84fa1ac4cd3979ed6b9637741faa8d0a71182f5c361f3530", 
        "encrypted_amount": 6416594240900873752, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "dd4955983d5bf3b88c763931b8a2d0f949018ddd4f705813b414e0751dad8a50", 
        "concealing_point": "f38c5efe7b6559b859fec57a156f050f2deb21ccd8674fcdd4c5e6af84c5b0c5", 
        "amount_commitment": "71f8aea04964553567e8afc885e05b27911ae40c3f96461223ef22239a02a52c", 
        "blinded_asset_id": "f6cdc1d72f09c1475f6f0cebaae1254b5170429a543602f362ea344087c966e3", 
        "encrypted_amount": 4403772117056187404, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "d1a0cceeff2b461e95e1b1120b35531267389bec6c4f08d283426faa913175c5", 
        "concealing_point": "ea9e0436773ffc114ae9546e6f27d54afba391e37228bee812da77429118f640", 
        "amount_commitment": "a980a5b7c1fe62634055ff3d64d1583aa662eb1f7afaae1eddaa14766d588c48", 
        "blinded_asset_id": "bdb6ee81c77c1df8a2b71ddf0cea2c2dfa892859b86ada041de3f98200c74e08", 
        "encrypted_amount": 2889839467904020472, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "2484dcf8288fcaa1d49107b8f15a8ebf15cb88fdba6099e56e67e34c9c844b6c", 
        "concealing_point": "f31e7423501359788484f1612be240c7c9cf9d66f6c7a5fbfa183d636aca275a", 
        "amount_commitment": "0f8deb6e829350b2994183ad22be118beb5f25c48746a9f1d75f0d0447994960", 
        "blinded_asset_id": "d5d51df31dd60a2d6cc970fbb3c2b047dc3da35da7cf6e64e789640dcd6b2f85", 
        "encrypted_amount": 17409214987419731501, 
        "mix_attr": 0
      }
    }, {
      "tx_out_zarcanum": {
        "stealth_address": "9d5a1c58ef93db3e02136da4c4d73eaa3d1746fff3982ff36786c5913b6b01af", 
        "concealing_point": "28cee03af7e72058a01bd328afebe9bd87d3c8a572bba26f8ef03fe7fc6b453f", 
        "amount_commitment": "99c03cc4f23f3dcf0b34e10cc6fcf5df9a8df8e1021c960328b0eea3b0875a05", 
        "blinded_asset_id": "a4de0f35195cb3233018b4879d956eba16401ed395aa96885db5edbb71f3dc4e", 
        "encrypted_amount": 17326452687893683450, 
        "mix_attr": 0
      }
    }
  ], 
  "attachment": [ ], 
  "signatures": [ {
      "ZC_sig": {
        "pseudo_out_amount_commitment": "cdf485e0a6f5ee29cb07c2b4c1c6630f65a4616e1f0a4f423ed6c3c1fd58a1f8", 
        "pseudo_out_blinded_asset_id": "7d45bcced49efdb52857cd061c5038cbdea6a9d1aae7074276929f4fc473d5d4", 
        "clsags_ggx": {
          "c": "2c3027623a8dbb698ce00bb4ed1a68adb944e6f1632cc6595c75a7d68a9be204", 
          "(std::vector<scalar_t>&)(r_g)": [ "996b9f265824f3456996a1b77a999550c65b3a71e97c1f4cee63e5e9f9d99807", "583b2b679191b01dbddca4ae042c36fe97bec28307af266fe416381a98498802", "6da7c3e2b9095b030c21937ab3cca666adcd5ec0ad0e56805daffa2b583c4a02", "a9cbb96ff8fb9745d77d64498d04cd59e27189e04d4a3f4e951ef2b8515e9302", "9db42fbba7beb993145d12d6fdfb2bc56f89f4aa0a86a9fec8960b3e9d4ef00d", "957ec9ba18fda1757dde37d1fd1f13e096520e836ae1938501d43939e0ed4d06", "044b83b2f2a512cfa04ea96ca05160e585b391f05af83c2f0db37de327b50f00", "b4f4205a123c3858691cd1589da92b69426710b75c1ea9f74288875751a74d07", "876e452156b007677849dca57696e4b074f0b6e9783c34413a190d2db6adf80f", "f78883621fecbb0a8e870416acdf179f3e242005f6c4545588ea5a6b83c17f07", "d2b3f1c08d8455b44694bb57ed6b9966a343e2709e6d3abea336e3620680b209", "a20d96b370022900cd960df073d63d5b282f37743c2cc8886a75a5a8a3504807", "d4c28cba591b6a2f9cbe78612d21495c4638965204f8995023256f9e6dd7df01", "ecb9e5c338ffb34c3d9f79c5001c20f9d3aec3f0e491a731270339f469b7330e", "8b9795040ace450e215c113c37b57d8e285e69bf522576e3384ad199512ef30b", "04cc3e3bca1af4412da0a3bc3bb348f9b10bea50a235ba1819c56fee66f2e300"
          ], 
          "(std::vector<scalar_t>&)(r_x)": [ "63ed3a27dbe27506dd71dc6cc6677524c070fc7cd73fbe3ec2af02a99fd3100f", "f839c1a0899a6aeb134499c71a461c94a138a852a4d26b44e9690ef3fc247009", "0dcdac4a8495a64fe01dd4a8bf04ed3d56525b7d808bc0ccf325b51ff0009001", "96b3a80faa01475bf1949da30a563217b0bb26f93450fe73aa0572c86868a70f", "58e7de0dd68cc5fb313223d6abc0fcc29d76d7923516640303af1dc881c7680a", "f98d8518959f4118189db6d273434cb856645a081d3ab669e87bd4adf6060b02", "165d5be6e11893e8e06adcfebeae1f14657f2220da7b69a93a43369d066eb901", "02b4e56e468e82af516fb779d01f50dad13d22a0de10cc8886f36867515dd703", "14e438f20ca4ed7ff26ec6bac05f7e6254d79952826e0d229bd190f02172bc0f", "f589773b5b4212844fbdc3b591274b7a7034d1cb7c925ac26e02a74f7ebbc602", "6382c078e374fa503cb666b2d95a5af73881b904411f6f6286581ce8626bd904", "4bb3a84e04c5715aebdd932dd900c284f6e9b04f899fadd569ff7a156fb9070e", "6943ca9ae5a542cb23f6e2cbd97cef3c88e674e0e20979160ec553de35b2d00d", "dc78243238fa98805a07e84e5a19d28bed4df4cf22979bd1d477e30dafc83802", "b1ae837e942a040365398ff4178b27b29250681306073e72aaf5750e372c1c01", "f35dc0db10f26f6b82922d0212135e336fe622fdaa0a5ca7a4bc3bea0a232500"
          ], 
          "K1": "1429c26e48d8b2adb4dadb998be08924d236a12e523d278c360839321a801d39", 
          "K2": "a1da29cf410b8135d24b356a8a5363f5410924f9165f3960674c7f9835717960"
        }
      }
    }
  ], 
  "proofs": [ {
      "zc_asset_surjection_proof": {
        "bge_proofs": [ {
            "A": "676e479592a71b6f7f7f1c755c2f8126fb6dfe61c10a5c3cd80089d70bfacbb8", 
            "B": "5beb2a9055190ae59c2405dcf73f2724d24f758d7dda7b6dacf2fa502e9a166a", 
            "Pk": [ "8ebb263f4a853cdfbdb0939b07a3936a7aec87d87869b01d13a4eb792a42cf0e"
            ], 
            "f": [ "fced15669fd4abc20f5f7c24a2f9b9b49450640b1f14e1d378588e45351f7803", "3b4b0e289b4486c03f6dfa884e8035ce5697728322052d40c21495f3d77f430d", "c6a0996f05e03686709fd2cd8620c801f07e6b3aa3d23d7605d68756d6b0e601"
            ], 
            "y": "7404f80ce02fc765114b48c0aa21b09b2a5f3da1fd9ae4b37847dfcf5e39c40d", 
            "z": "cff28805d8d3f1f589469c1eb8f6247aae0e02bf71560472de81fcbbbe91930a"
          }, {
            "A": "25ad5f5657a12931e43a73439d855ae2048e356f297b1e6298a26bb8c61e60ad", 
            "B": "9722ff1cdfdc9fffb08953919c5793537a1ed47679caa0d4d92af2dd16e30b56", 
            "Pk": [ "1db15ab700705d60187ffbcf32566edb50cba95e4de70ed58c8473460d031a74"
            ], 
            "f": [ "3cad249f88153e2a93d510aae5f3c8193c64d28e8cb0f0d4b353f65c722b9b0f", "d688981479183c2b8f8fd4b2547967b693988374a19cf4913170e13c0832c309", "e0302d92146c7f05566dc1e6ea39f962601f4f22cddf01d0a230c522cdecc605"
            ], 
            "y": "52fa69f08f36fd53406398cbfa54ddfa34049d8addfa370430a01d3a657dd80c", 
            "z": "a1667455cc73e65adca66cc3429a4a60f990bbc5886ebdbd7a8f6e39580d800d"
          }, {
            "A": "30574197f1e3181fbfcd3041367550612e4a851f3b7978c4527f375abb897971", 
            "B": "8b0efe437b2ef2dac0d43106e14d93b3b5fbd72d650ed873ed39c650095e0b32", 
            "Pk": [ "6b5291117eef5d9918a628d1674a6c2153256f8190a7a911387be15083c35572"
            ], 
            "f": [ "ce26ae771fdd9f5930538831429aece17e353ec4ceec510a6bd906c101ca5804", "366cccee0c93abad8ca70e17c9f68ea2f5ea40a32d1496530a555df6c4737602", "c4ef45fa1fa07edb68bac43559a2e6e10dc579c55dcd064992beda7f8a044b07"
            ], 
            "y": "9755134b79475a934d900bb8c3cc388fe140fc3203ad63942c297e47ba297b0d", 
            "z": "4d451ffc94a028f677e3a40c7432fd96f0bfe9dc407a544fd67b6bd8a5001d01"
          }, {
            "A": "0ae3e370bfea06e7504e0e5e6f22cb59939ae36d81d66f1a87b498092a223c53", 
            "B": "d1d15a4e4299dc6dabe62c8b44becdd862a35d98d08d06687b8e9b095e3287bc", 
            "Pk": [ "301e291380731c289a2dcf692254a31413ec83bb9aaf3006727a438f649795a6"
            ], 
            "f": [ "9ce014a3126a98132195f8f79f924504ce0780f7e0bed63f10c90b1a37fbf604", "d7821e2669e0fbe76ae1b75715296f0a86f4d5e2b79884eaee6f2eebdea5ed0e", "1a58287d6eb4fc968c28174175fe28c3af13f33a1f8e6fb0c6abe79fa411b109"
            ], 
            "y": "b185f41a1ff277757df597cea22c8aef57153f9d545df0f2b7d860213d93c600", 
            "z": "80bc154f9bb10530d6d49344a9a0a6cd9bd2af4d1131b972353f3a431efdfa0d"
          }, {
            "A": "63bf2acc53d33ae9f1440f27d35c9c48170780424cba55673cfc25c464cedb2e", 
            "B": "36fb75b5c795c45fd851568cd3a8fff9236022f80504c5dc5dec1da1b26ef40f", 
            "Pk": [ "53b357ea211e5600bc8229c2e7dd257c92ede0a4bf8ec569e393a39ea306f20f"
            ], 
            "f": [ "fb050715cd4e223fbf401cade3d7f86f0787d10587e66099c5cf1056247ae607", "8ae0684f2c16df70fe34e43a6c6a04b94ede81904edfbd80c5d7d23b696ae307", "ab7698c41507ac3c6cb9a9f35f8f74cb2e1ba81b5a4498f78803c72901922204"
            ], 
            "y": "a6d495d74954ba55146c2f8e79e70faee7da94a6617dc221a9e6e5542c582805", 
            "z": "74362d6b77849915273edb1b0752041ef10ac3b931177a60dca4b6f4e5698d0e"
          }, {
            "A": "30f25e2d0e9d147b54659d0048569f47f3321fa933be33eb31a73d5a03e4485d", 
            "B": "06b1a682ff769d237db96b3530c787b312095ac2cb54c3673ca7acf60f6361ee", 
            "Pk": [ "4e9a121d67e4edf58c0a09e89e0e01b477cfd968a710d029c43b0fbcf3827c72"
            ], 
            "f": [ "a7020d1d8374b7810b4d3d55ddd5e794f4d5ba0f92cb9dc1de141980a6dcc503", "b58cb8773250984ecb34f77ec6ba98fb46d7de87aafe073e0a5ccb4967d22d02", "ed4926997bbd64abe2d21c82c091eecee0657351217eceeeb914dadb84beed05"
            ], 
            "y": "f9f3c0066238052f26c39e4f064853b45fc91223409d2c257c02c2afcb636802", 
            "z": "a2079eee4e8017481a4aa72cf31729f6b5a7228aa5c94745dd921debc2556508"
          }, {
            "A": "5c190be54a41b1789f0a5b51ab175add1b670452950398bbab8561e384f64420", 
            "B": "a999521ebda097a97ed1a4067079c1514e7a1a16f85d717a6b093e0253dd0a70", 
            "Pk": [ "00560d4bd177328394fbad76b9f9952701f26517d8811794f632745143b1f57c"
            ], 
            "f": [ "6a4ecb6ce16cb2f2dd3f474766ba5c32aeba8369036d54b9e6a3c886a3eed407", "020e130ed8322673f8dd09d37e626bf5bbc44c3fcbb54eb5deec7fb0f396280b", "d9480424161a9414c8761f94b2f287b8cfbd149410b4b1634a5ecf8595ab9805"
            ], 
            "y": "7ba69bf1196173bffec9de80d8410466f86c787e41e711b672b3753ba684a50e", 
            "z": "3dc44b92180344a978030c23da4dadeca7e6e51a7e62945d07a7da422dfa540a"
          }, {
            "A": "4e5dacdfaefba240c6761001a19e61810f8cb2236027172d66c128a0e84ad745", 
            "B": "db9c89377346a44de529f2b5fc1e2eb49f2c593f351e3aacb67507c7d78ce26e", 
            "Pk": [ "0c3075cfd229bee52d4463a74251fb0fc3fcba94534208fffead1a4ae1b8e65b"
            ], 
            "f": [ "e1d367fa62e45a7c8fd22c1b4228fcbf708d7498b3c9f2c61072d1bc039abf00", "6a41bff131cc93a96278c68879bbeb595e6b17423c03701d0e3b1de550b67703", "31c5bd4ad85e28a5b33ed9c8cc99ac5ff3f225418b0861b03ec15d1478a42602"
            ], 
            "y": "d2c8a18d64544702bdfb5aa8fb28962f25e71f89be4682fe38a70321c44da10d", 
            "z": "61ec6f795df5c1a8ca50656484dcbb05a7409c24ad7f5adaa1d49ba01630c20f"
          }, {
            "A": "627c52ec2e845a399fd11c02f40485b27c84ff98d6b5fef626fca3251e9fecea", 
            "B": "109554863288e9dc75b5d0b4977755c00202f5693a527094d54614997fb56350", 
            "Pk": [ "60f5fb92b72c1b5e8959ce85b4264b32f72c373b3e6d11caf1dc030939795519"
            ], 
            "f": [ "5849ff77e424f7212e551b95e2ce488c3a8d1c00a0e0d002b90cacc102c6fa0e", "62bf0aca1cc597b23604c93c530bb88a8d1bf7bd53b458d568bc2600e927a604", "22a4ece40b052f9e85e8bf94fdc27147c7d04195e969c2ccd10531f54559c90a"
            ], 
            "y": "620537a498f99003ab4a06cb7c973c895088755495473ffdc9e724782aa31f0c", 
            "z": "6d0de20d0fa1b95e03eaf962a0c8aea7ed46492e2d21c8b64c57b069ce569e05"
          }, {
            "A": "76073be140891cb526b0438135aa4653b923fbe17a0f0eee51aefb2699cdd245", 
            "B": "9b3965e214d476d58dcb57981cc008bf59f5246588e3231419f90564b040dfb3", 
            "Pk": [ "a12fde06b1a566eebac30c4b7607a21828d4335c501946783cb6635fa5c7a325"
            ], 
            "f": [ "fda97b313ef8b0a43348fedb1d57184a8afdf54fb7ac14e6351919d6ae6ff00f", "cd14bf6de5a7f4aa3eb43274c3344cb031a98ddee456bce67f10e94835105d08", "8a77ad94b6245095463a2242c6e87120ec3ed0a1cb1a07ae5c3c42371d58f90c"
            ], 
            "y": "f33b3ac4fddcaa46f190246855c4425b4563f13e619929cc3f9d0ca550a90507", 
            "z": "17b2f793a4d5f80d2958b3fef06fbdd1d6a137d800d7eb3bb9f28163d2bae600"
          }, {
            "A": "eac7bcb78c69236e5952b2394f3b6fbcb3a287017e0ca9fe9ea0a7bef7a22703", 
            "B": "f8f3c4331f9152ae012e49729fe3c2e2ef19c571a13a3e5b0311ec094f0c1959", 
            "Pk": [ "47b483f8259ef73b06bea095993e1c38b26c59e8ee312f6a60c04124b9805d6c"
            ], 
            "f": [ "fb6c9fdd219e8164ed4626ce56e28528cc547578480c36b6db50492e3920f507", "75a835bcb1206fab39de8e69767bc76d102a07c2d72bd3fcdd74b6ea5d14e102", "b026b6baf59494b5b5e73930d1589608425ad316688fb2f6179c6d017f56e202"
            ], 
            "y": "67efb546be22bb352b293d5c3b554e65c63fa3286d284674b4ac3f0ea7547f04", 
            "z": "0fdfe66907e0164e6cb681aa520a7581f0f547faf530bc23621beefa921ed100"
          }
        ]
      }
    }, {
      "zc_outs_range_proof": {
        "bpp": {
          "L": [ "70c7a75eddff9329235ff243d819df216ca03f7ecae3bd18538131b8b9754f6c", "78ec0a6b022818ef679d805289a34b3c82595525d2e4302c38ef02b850c1d7c9", "84fbb167ae3da2a8bd295a5029729bee536c5e634ca50e6afbee9de390d98581", "68dd687ea3b29a66ee789835cc0948c15a45d5c9e49d30b48c1ee37a03fc971d", "4905d2145228a4a9303ed532321b0e672cc61e7047bc5de35fd59275525e8092", "73da394d9ce16ad9b895f703d82bde98f3252b980e598e59f328b7d55991acfe", "7a676daa72a78929c73e285e8a3f5d26b3bf8d3932346ec986a89ec6d8276ebf", "798e901164c9979fc0c40a7a1803264ba34fb34dcfb47245e2fede55e6ceca3f", "485d5c568a36e542a54c97329ea119f5a55fd6fad20aa2c7446d1f34868af677", "53b74525b1b780fc5a4945e35c7d00971fd35d1dddeb544896e57341321fbc73"
          ], 
          "R": [ "a0722b0d835091b31c8dda05658f784060d1146733cf95fd5efc60e45be3ac8e", "4816e528728a44c98b78301b746b8d28760de6f023a74710d82134217a8337b0", "71b9166765706f26fa1d12ec478a925ca49f3d836ec46f6f00deb536d92a2a3f", "72a3df4991440c9041f0d8b35001a3810445664110b30ac440786c536da1a7f3", "9aca1e2969a17d2c394bab956e073397434f02e0bbc587d1fcea4d5350661794", "1d77328d57f309fc57784a7aea5dd2ff2bc321d90c87c5b64a00f4cd639b9bd5", "8892d0df76df20dee91f160e15da3c797750ee5c6e5ef74af011f7100f03875e", "8a28c57bd62e6d5ba4de0a0e5161c57de230aae9028f4abd7d225a36a41fefd1", "bb02ac045f6c872ab2dffb04b1cd715ef2497172b7f28a82a5b33f1aa1ccb288", "a608fed4ace8cbedc7e616096e76aba888b60ea148e57d8074f9e833ac458dcf"
          ], 
          "A0": "6b38f791e755521eb0097567d3f0213980f10b467e86f4fa505810172b1fb823", 
          "A": "38d3fd5e4b4cd0ddba3c4be335b88d21d29004640e55db2c7c9c480c0339f44e", 
          "B": "a7e10273c20a9ad7d1905bca0491553146cdd141575002c019a9823ec93082b7", 
          "r": "8bd9f93a0358d9029f9a058c62142526452480a680e5ab6ca5e3f7fdda6fb105", 
          "s": "36e8c2437082b6dc53a29999cc33cf484cb95a5fc62d0645d4ceeba20b312500", 
          "delta": "883fd5a18b7711b01a7449219f0e59f1e995fd7eece140519af64bec79941d01"
        }, 
        "aggregation_proof": {
          "amount_commitments_for_rp_aggregation": [ "c2edb61520aac7aeb943de7ad216d32125338298327fa7bbd03a26b493b19995", "ef3d30f43387fd1d290adc15beeab10d5ce39b4c1cef6870a59e47013e2a7c47", "f915f891634fa4b5de06a40725affb295fcbf161c2051e0cc0fefb29178fff15", "24946272da9fea32fd07763aab4f3a14766b992b57ae0bd6b5188e4cc2d194b7", "ad6363a0841bec4eb5b5942360b262e4bfd5fc5f9b989c6cd524b5aa9e9ef1ef", "2aed059095d2bc75662e6e8b65912321642cbd9d995d3006d2bce1109f748f46", "812ab63335c40aa3e8c10ab00adde34e94316f7ed63e0285fd86d4e639bedf42", "af68409dfb5fd981b28bb795b6e13f64db1fa124beb0dc294bda97b8a2ef5c88", "1b6cb792693fb41774f4bef22957fbc554e284256d3387bacced4ac1e416fc56", "4756f3a2f4702e45fe96dd7c8774a47d437cd767f7dc6e61d7adad3fe851203d", "c16f6f2348b7b5dbc6d333dfba20531593d006f4d8f1c571d1848deb2f37ec35"
          ], 
          "(std::vector<scalar_t>&)(y0s)": [ "55d9742e1630bdcb0b171645e71ca613957caa70e00c7425be9744efb7a18e01", "6c0ca4a28c2e123dcf8fd9c50178433fcc5739257fcca3ece9002cea958b8c00", "d02f1c917651913fdf28b1b1ca831bf395a0eb2fe0bceb44b7baaa5ad6f08f00", "c0f3b8d3896899eb17757033f481b86848ef41558376face3793ee7b7fabc808", "fdafb170bd1788ad12649a164226c39132ffcf9f1ed5ac2e04d24c5725b17002", "8a4eadf84b2a4b218404da7ca6a686889b9eca13394c88080339bda5ac4e8c0b", "23e2f23a3352102bde0737247c6b7584ebbbdddcaff7369aae1dd2359b12190a", "65eb0ef3996e62147b4e19a7dd3296259d19181089d78e20735a3805e4cc4101", "392386925e83a6dcf670274f9273b908c3d46811fa7d4b9e547e6b4b64452d09", "9b798b3ec680e418eb56d865f5975c6d054ecd652661f4b3fc13bf723dda6806", "c1621924fe302f6e1c846802b4a9456506d7b1d58811c7e1de77a5a7a1262d0c"
          ], 
          "(std::vector<scalar_t>&)(y1s)": [ "aceeb6651d6525381f2109e90f847414f837d7f9ed7611f1e9f07cee34a8a304", "76ee0b514c54b3b8c761b79f72560288a865f381770e54e478035bb574b44008", "0532022cea6a9d946fbb58710f7ce3dec0303cdd633342e8e8db50878b7f1601", "923c4fcba7b984bc1ef615691c14e07839e3401932f42a6b3cd4f0d0bbb6f209", "f8279edff8c794a2f71e37df2395cc785887661544b65e57b3f98b9376342301", "2c539bc4fba4f48b61a5b4d1e5e74747c51592b4918c959e7872839552eed608", "c79bb1acb3f794c2ea558ff556b362fd0bffa05e117ac63b8952a2ddd2ab990e", "15a6b9eecd0d2a159f69e405ed661ff91367df72234d51d53e6f686abc94de05", "625ff7d54140750dc4d5ab7e0546dfe0830c77ee3b00cdb6040f96a7d1a62507", "379a2a53eaa02a51359dc8ea1cb5da17d3016d88dee61883e4655d95c7fc430a", "b0ca714452668717e0076f5cde29f181882f3fbc400076d2b36427c0e8e0370d"
          ], 
          "c": "6266896f214f490e0ecf28aafe3a9efb0fcfc19aac96ff4e8cbe3ed25b8de002"
        }
      }
    }, {
      "zc_balance_proof": {
        "dss": {
          "c": "804ee7dcaa8060cfbf6ed30b87c4ea1116a5459dc0dfb710f03cf5e2cd9d720e", 
          "y0": "08b577647fd7d287cf69fa4c15464507375535467a170cbe40ca749bf479bd0e", 
          "y1": "6a97280e380b5115a15772999147adb9cfcab3e4ec1acc0be7757ba9a4f23509"
        }
      }
    }, {
      "asset_operation_proof": , 
      "VERSION": 0, 
      "opt_amount_commitment_composition_proof": "01", 
      "opt_amount_commitment_g_proof": "00""6028212a449a9bf714ea1e26c6a052fbe857ad8b32ed6d970c8314a812487b00139430194841ef099383d49865fd8a48984ada2fe255d6e77d4c540a74516e0d"
    }
  ]
}", + "verified_tx_id": "dda68dedd826dc9c7391c6f5c49b7ab96ea041a6e2d9eba3afbeaa5564e17bfc" + } +} \ No newline at end of file diff --git a/utils/JS/emmit_response.json b/utils/JS/emmit_response.json new file mode 100644 index 00000000..0cdcd566 --- /dev/null +++ b/utils/JS/emmit_response.json @@ -0,0 +1,25 @@ +{ + "id": 0, + "jsonrpc": "2.0", + "result": { + "data_for_external_signing": { + "finalized_tx": "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", + "outputs_addresses": [ + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK" + ], + "tx_secret_key": "1aee5ddadc7845df39da5336271c8501f5d98bbabbf651bf2d0a297c05babf06", + "unsigned_tx": "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" + }, + "tx_id": "dda68dedd826dc9c7391c6f5c49b7ab96ea041a6e2d9eba3afbeaa5564e17bfc" + } +} \ No newline at end of file diff --git a/utils/JS/package-lock.json b/utils/JS/package-lock.json new file mode 100644 index 00000000..268530ac --- /dev/null +++ b/utils/JS/package-lock.json @@ -0,0 +1,192 @@ +{ + "name": "JS", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "dependencies": { + "axios": "^1.7.7", + "ethers": "^6.13.2" + } + }, + "node_modules/@adraffy/ens-normalize": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.10.1.tgz", + "integrity": "sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==" + }, + "node_modules/@noble/curves": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.2.0.tgz", + "integrity": "sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==", + "dependencies": { + "@noble/hashes": "1.3.2" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@noble/hashes": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.2.tgz", + "integrity": "sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@types/node": { + "version": "18.15.13", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.13.tgz", + "integrity": "sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==" + }, + "node_modules/aes-js": { + "version": "4.0.0-beta.5", + "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-4.0.0-beta.5.tgz", + "integrity": "sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==" + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" + }, + "node_modules/axios": { + "version": "1.7.7", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz", + "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==", + "dependencies": { + "follow-redirects": "^1.15.6", + "form-data": "^4.0.0", + "proxy-from-env": "^1.1.0" + } + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/ethers": { + "version": "6.13.2", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-6.13.2.tgz", + "integrity": "sha512-9VkriTTed+/27BGuY1s0hf441kqwHJ1wtN2edksEtiRvXx+soxRX3iSXTfFqq2+YwrOqbDoTHjIhQnjJRlzKmg==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/ethers-io/" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@adraffy/ens-normalize": "1.10.1", + "@noble/curves": "1.2.0", + "@noble/hashes": "1.3.2", + "@types/node": "18.15.13", + "aes-js": "4.0.0-beta.5", + "tslib": "2.4.0", + "ws": "8.17.1" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/follow-redirects": { + "version": "1.15.9", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz", + "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/form-data": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz", + "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/proxy-from-env": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", + "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==" + }, + "node_modules/tslib": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", + "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==" + }, + "node_modules/ws": { + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz", + "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + } + } +} diff --git a/utils/JS/package.json b/utils/JS/package.json new file mode 100644 index 00000000..4d61e812 --- /dev/null +++ b/utils/JS/package.json @@ -0,0 +1,6 @@ +{ + "dependencies": { + "axios": "^1.7.7", + "ethers": "^6.13.2" + } +} diff --git a/utils/JS/sign_response.json b/utils/JS/sign_response.json new file mode 100644 index 00000000..71531860 --- /dev/null +++ b/utils/JS/sign_response.json @@ -0,0 +1,8 @@ +{ + "id": 0, + "jsonrpc": "2.0", + "result": { + "status": "", + "transfers_were_unlocked": false + } +} \ No newline at end of file diff --git a/utils/JS/test_eth_sig.js b/utils/JS/test_eth_sig.js new file mode 100644 index 00000000..d8895cc5 --- /dev/null +++ b/utils/JS/test_eth_sig.js @@ -0,0 +1,227 @@ + + +const axios = require('axios'); +const { ethers } = require("ethers"); +const { exit } = require('process'); +const fs = require('fs'); + +/// Define an async function that takes method name and parameters +async function callJsonRpc(requestData, port = 22222) { + try { + const response = await axios.post('http://127.0.0.1:' + port +'/json_rpc', requestData, { + headers: { + 'Content-Type': 'application/json', + }, + }); + + // Return the result from the JSON-RPC response + return response.data; + } catch (error) { + console.error('Error:', error); + throw error; // Optionally rethrow the error to handle it in the calling function + } +} + +function reverseHexBytes(hexString) { + // Ensure the hex string length is even + if (hexString.length % 2 !== 0) { + throw new Error("Invalid hex string length"); + } + + // Split the hex string into chunks of 2 characters (1 byte) + const bytes = hexString.match(/.{1,2}/g); + + // Reverse the array of bytes and join them back into a string + const reversedHex = bytes.reverse().join(''); + + return reversedHex; +} + +async function deploy_asset() +{ + try { + //Generated Private Key: 0x17a938099954cee510d7fc9eb2366f0762b093d9be547acabf8be85f774ef154 + //Generated Address: 0x0886bA9F5b117D2A3C1ce18106F2Ce759f5D34C8 + + const loadedWallet = new ethers.Wallet("0x17a938099954cee510d7fc9eb2366f0762b093d9be547acabf8be85f774ef154"); + console.log("Loaded Address:", loadedWallet.address); + console.log("Public key:", loadedWallet.signingKey.compressedPublicKey); + const owner_eth_pub_key = loadedWallet.signingKey.compressedPublicKey.substring(2); + console.log("Generated Public key HEX:", owner_eth_pub_key); + const jsonObject = { + id: 0, + jsonrpc: "2.0", + method: "deploy_asset", + params: { + asset_descriptor: { + //current_supply: 1000000000000000, + decimal_point: 12, + full_name: "Zano wrapped ABC", + hidden_supply: false, + meta_info: "Stable and private", + owner: "", + ticker: "ZABC", + total_max_supply: 1000000000000000000, + owner_eth_pub_key: owner_eth_pub_key + }, + destinations: [ + { + address: "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + amount: 1000000000000000, + asset_id: "" + }, + { + address: "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + amount: 1000000000000000, + asset_id: "" + } + ], + do_not_split_destinations: false + } + }; + + const res = await callJsonRpc(jsonObject); + console.log("deploy_asset response: " + JSON.stringify(res, null, 2)); + /* + deploy_asset response: + { + "id": 0, + "jsonrpc": "2.0", + "result": { + "new_asset_id": "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + "tx_id": "73ff52bf4d85153f2b25033dd76e9e92e63214ed983682182e6e2b2ce0ecf46c" + } + } + */ + } + + catch (error) { + console.error('Error occurred:', error); + } +} + +async function emmit_asset() +{ + try { + + //Generated Private Key: 0x17a938099954cee510d7fc9eb2366f0762b093d9be547acabf8be85f774ef154 + //Generated Address: 0x0886bA9F5b117D2A3C1ce18106F2Ce759f5D34C8 + // asset_id 7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf + + //var use_pregenerated_files = false; + + const loadedWallet = new ethers.Wallet("0x17a938099954cee510d7fc9eb2366f0762b093d9be547acabf8be85f774ef154"); + + console.log("Loaded Address:", loadedWallet.address); + console.log("Public key:", loadedWallet.signingKey.compressedPublicKey); + const owner_eth_pub_key = loadedWallet.signingKey.compressedPublicKey.substring(2); + console.log("Generated Public key HEX:", owner_eth_pub_key); + var res_emmit; + //if(!use_pregenerated_files) + //{ + const requestDataEmit = { + id: 0, + jsonrpc: "2.0", + method: "emit_asset", + params: { + asset_id: "7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf", + destinations: [{ + address: "ZxC1U6hoCRM9PBSwrBTrWD8XgcHqLNJN9NWqXs9o994eZuHHBvSAyBpQ4TbWSNoabUDPdD8iEM5ZjPoMM7jE48mp2iKcVHLSK", + amount: 100000000000, + asset_id: "" + }], + do_not_split_destinations: false + } + }; + + res_emmit = await callJsonRpc(requestDataEmit); + fs.writeFileSync('emmit_response.json', JSON.stringify(res_emmit, null, 2)); + console.log("emmit_response response: " + JSON.stringify(res_emmit, null, 2)); + //}else + //{ + // const data = fs.readFileSync('emmit_response.json', 'utf8'); + // res_emmit = JSON.parse(data); + //} + + var res_decrypt; + //if(!use_pregenerated_files) + //{ + const requestDataDecrypt = { + id: 0, + jsonrpc: "2.0", + method: "decrypt_tx_details", + params: { + outputs_addresses: res_emmit.result.data_for_external_signing.outputs_addresses, + tx_blob: res_emmit.result.data_for_external_signing.unsigned_tx, + tx_id: "", + tx_secret_key: res_emmit.result.data_for_external_signing.tx_secret_key + } + }; + + res_decrypt = await callJsonRpc(requestDataDecrypt, 12111); //request to daemon + fs.writeFileSync('decrypt_response.json', JSON.stringify(res_decrypt, null, 2)); + console.log("decrypt_response : " + JSON.stringify(res_decrypt, null, 2)); + + + //}else + //{ + // const data = fs.readFileSync('decrypt_response.json', 'utf8'); + // res_decrypt = JSON.parse(data); + //} + + const bytesToSign = ethers.getBytes('0x' + res_decrypt.result.verified_tx_id); + const signature = loadedWallet.signingKey.sign(bytesToSign).serialized; + const signature_without_0x = signature.substring(2); + console.log("Generated signature: " + signature_without_0x); + // Strip the last byte (recovery parameter) to get 64 bytes + const strippedSignature = signature_without_0x.slice(0, -2); // Remove the last byte (2 hex chars) + + const requestSendSigned = { + id: 0, + jsonrpc: "2.0", + method: "send_ext_signed_asset_tx", + params: { + eth_sig: strippedSignature, + expected_tx_id: res_decrypt.result.verified_tx_id, + finalized_tx: res_emmit.result.data_for_external_signing.finalized_tx, + unlock_transfers_on_fail: false, + unsigned_tx: res_emmit.result.data_for_external_signing.unsigned_tx + } + } + + const res_sign = await callJsonRpc(requestSendSigned); + fs.writeFileSync('sign_response.json', JSON.stringify(res_sign, null, 2)); + console.log("sign_response response: " + JSON.stringify(res_sign, null, 2)); + } + catch (error) { + console.error('Error occurred:', error); + } +} + +async function main() +{ + try { + + /* + await deploy_asset(); + TODO: wait for 10 confirmations + //wait for 10 confirmations + + //asset id 7d51ecaad2e3458e0d62b146f33079c6ea307841b09a44b777e0c01eb11b98bf + */ + await emmit_asset(); + + + + + + + + } catch (error) { + console.error('Error occurred:', error); + } + +} + + +main(); From fc3922996dfeefe4aff3e76e77674580bb6c420f Mon Sep 17 00:00:00 2001 From: cryptozoidberg Date: Tue, 1 Oct 2024 15:59:27 +0400 Subject: [PATCH 06/10] added comments to JS code --- utils/JS/test_eth_sig.js | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/utils/JS/test_eth_sig.js b/utils/JS/test_eth_sig.js index d8895cc5..535f7019 100644 --- a/utils/JS/test_eth_sig.js +++ b/utils/JS/test_eth_sig.js @@ -116,6 +116,11 @@ async function emmit_asset() console.log("Public key:", loadedWallet.signingKey.compressedPublicKey); const owner_eth_pub_key = loadedWallet.signingKey.compressedPublicKey.substring(2); console.log("Generated Public key HEX:", owner_eth_pub_key); + + ////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////// + //this part is performed on coordinator node: + var res_emmit; //if(!use_pregenerated_files) //{ @@ -143,6 +148,12 @@ async function emmit_asset() // res_emmit = JSON.parse(data); //} + + ////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////// + //this part is performed on validator node: + + var res_decrypt; //if(!use_pregenerated_files) //{ @@ -162,6 +173,7 @@ async function emmit_asset() fs.writeFileSync('decrypt_response.json', JSON.stringify(res_decrypt, null, 2)); console.log("decrypt_response : " + JSON.stringify(res_decrypt, null, 2)); + //TODO: response holds all information about what this transaction actually transfer and to what addresses //}else //{ @@ -169,8 +181,17 @@ async function emmit_asset() // res_decrypt = JSON.parse(data); //} + + ////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////// + //this part is performed with TSS scheme: const bytesToSign = ethers.getBytes('0x' + res_decrypt.result.verified_tx_id); const signature = loadedWallet.signingKey.sign(bytesToSign).serialized; + + ////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////// + //this part is performed on coordinator node with given signature: + const signature_without_0x = signature.substring(2); console.log("Generated signature: " + signature_without_0x); // Strip the last byte (recovery parameter) to get 64 bytes From e77831f1f9d23f34e5d3f7445b2b906282890330 Mon Sep 17 00:00:00 2001 From: cryptozoidberg Date: Tue, 1 Oct 2024 20:31:42 +0400 Subject: [PATCH 07/10] little tweak on wallet unconfirmed balance --- src/wallet/wallet2.cpp | 9 +++------ src/wallet/wallet_rpc_server.cpp | 2 +- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp index 20745cdf..f7078763 100644 --- a/src/wallet/wallet2.cpp +++ b/src/wallet/wallet2.cpp @@ -3754,13 +3754,10 @@ bool wallet2::balance(std::unordered_mapsecond)) // if is_incoming == false, then we need to check for change and add it to total + if (it_employed_entry == subtransfers_by_assets_map.end() || !(it_employed_entry->second)) // if is_incoming == false, then we need to check for change and add it to total { + //it_employed_entry == subtransfers_by_assets_map.end() is a case when amount sent exactly equal amount received (someone producing more outputs for example) + //still need to add to total as it is a change wallet_public::asset_balance_entry_base& e = balances[emp_entry.asset_id]; e.total += emp_entry.amount; } diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp index 1a372db9..069e6856 100644 --- a/src/wallet/wallet_rpc_server.cpp +++ b/src/wallet/wallet_rpc_server.cpp @@ -1433,7 +1433,7 @@ namespace tools res.status = e.what(); return true; } - res.status = API_RETURN_CODE_OK; + res.status = API_RETURN_CODE_OK; return true; WALLET_RPC_CATCH_TRY_ENTRY(); } From 3daaad6d4338947d1045969956e82fef2afb4f3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=D1=91pa=20Dolgorukov?= Date: Tue, 8 Oct 2024 20:30:23 +0500 Subject: [PATCH 08/10] coretests: implemented test "asset_current_and_total_supplies_comparative_constraints" (#464) --- tests/core_tests/chaingen_main.cpp | 1 + tests/core_tests/multiassets_test.cpp | 340 ++++++++++++++++++++++++++ tests/core_tests/multiassets_test.h | 19 ++ 3 files changed, 360 insertions(+) diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp index 65adc003..cc4a8e17 100644 --- a/tests/core_tests/chaingen_main.cpp +++ b/tests/core_tests/chaingen_main.cpp @@ -1296,6 +1296,7 @@ int main(int argc, char* argv[]) GENERATE_AND_PLAY_HF(asset_operation_and_hardfork_checks, "4-*"); GENERATE_AND_PLAY_HF(eth_signed_asset_basics, "5-*"); // TODO: make HF4 version GENERATE_AND_PLAY_HF(eth_signed_asset_via_rpc, "5-*"); // TODO: make HF4 version + GENERATE_AND_PLAY_HF(asset_current_and_total_supplies_comparative_constraints, "4-*"); GENERATE_AND_PLAY_HF(pos_fuse_test, "4-*"); diff --git a/tests/core_tests/multiassets_test.cpp b/tests/core_tests/multiassets_test.cpp index 813999e4..58b047b4 100644 --- a/tests/core_tests/multiassets_test.cpp +++ b/tests/core_tests/multiassets_test.cpp @@ -1952,3 +1952,343 @@ bool eth_signed_asset_via_rpc::c1(currency::core& c, size_t ev_index, const std: return true; } + +asset_current_and_total_supplies_comparative_constraints::asset_current_and_total_supplies_comparative_constraints() +{ + { + auto& adb{m_adbs.at(asset_position::alpha)}; + adb.full_name = "Alpha"; + adb.ticker = "ALPH"; + adb.current_supply = adb.total_max_supply = 0; + } + + { + auto& adb{m_adbs.at(asset_position::beta)}; + adb.full_name = "Beta"; + adb.ticker = "BETA"; + adb.current_supply = adb.total_max_supply = 1; + } + + m_ados_register.at(asset_position::alpha).operation_type = ASSET_DESCRIPTOR_OPERATION_REGISTER; + m_ados_register.at(asset_position::beta).operation_type = ASSET_DESCRIPTOR_OPERATION_REGISTER; + m_ado_emit.operation_type = ASSET_DESCRIPTOR_OPERATION_EMIT; + + REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_asset_alpha_not_registered); + REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_asset_beta_registered); + REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, emit_asset_beta_with_incorrect_supply); + REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_asset_beta_not_emitted); + REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, public_burn_asset_beta_with_incorrect_supply); + REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_alice_final_balance_native_asset); +} + +bool asset_current_and_total_supplies_comparative_constraints::generate(std::vector& events) const +{ + /* Test ideas: + * ensure that it's impossible to register asset with .current_supply = .total_max_supply = 0; + * ensure that asset operations in which .current_supply is greater than .total_max_supply are not performed. */ + + bool success{}; + GENERATE_ACCOUNT(miner); + GENERATE_ACCOUNT(alice); + transaction tx_0{}, tx_1{}, tx_2{}, tx_3{}; + + m_accounts.push_back(miner); + m_accounts.push_back(alice); + m_adbs.at(asset_position::alpha).owner = m_adbs.at(asset_position::beta).owner = alice.get_public_address().spend_public_key; + m_ados_register.at(asset_position::alpha).descriptor = m_adbs.at(asset_position::alpha); + m_ados_register.at(asset_position::beta).descriptor = m_ado_emit.descriptor = m_adbs.at(asset_position::beta); + CHECK_AND_ASSERT(m_ado_emit.descriptor.current_supply <= m_ado_emit.descriptor.total_max_supply, false); + ++m_ado_emit.descriptor.current_supply; + CHECK_AND_ASSERT(m_ado_emit.descriptor.current_supply > m_ado_emit.descriptor.total_max_supply, false); + + MAKE_GENESIS_BLOCK(events, blk_0, miner, test_core_time::get_time()); + DO_CALLBACK(events, "configure_core"); + REWIND_BLOCKS_N(events, blk_0r, blk_0, miner, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + + { + std::vector sources{}; + std::vector destinations{}; + + success = fill_tx_sources_and_destinations(events, blk_0r, miner.get_keys(), alice.get_public_address(), MK_TEST_COINS(3), TESTS_DEFAULT_FEE, 0, sources, destinations); + CHECK_AND_ASSERT_EQ(success, true); + success = construct_tx(miner.get_keys(), sources, destinations, empty_attachment, tx_0, get_tx_version(get_block_height(blk_0r), m_hardforks), 0); + CHECK_AND_ASSERT_EQ(success, true); + } + + ADD_CUSTOM_EVENT(events, tx_0); + MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner, tx_0); + REWIND_BLOCKS_N(events, blk_1r, blk_1, miner, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + + // Alice registers asset ALPH. Transaction is invalid, because .current_supply = 0, .total_max_supply = 0 in the asset base descriptor. + if (const auto& top{blk_1r}; m_hardforks.is_hardfork_active_for_height(ZANO_HARDFORK_05, get_block_height(top))) + { + std::vector sources{}; + std::vector destinations{}; + const auto& ado{m_ados_register.at(asset_position::alpha)}; + transaction tx{}; + crypto::secret_key one_time{}; + + success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(3), TESTS_DEFAULT_FEE, 0, sources, destinations); + CHECK_AND_ASSERT_EQ(success, true); + destinations.emplace_back(ado.descriptor.current_supply, alice.get_public_address(), null_pkey); + CHECK_AND_ASSERT_EQ(ado.descriptor.total_max_supply, 0); + CHECK_AND_ASSERT_EQ(ado.descriptor.total_max_supply, ado.descriptor.current_supply); + success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); + CHECK_AND_ASSERT_EQ(success, true); + DO_CALLBACK(events, "mark_invalid_tx"); + ADD_CUSTOM_EVENT(events, tx); + DO_CALLBACK(events, "assert_asset_alpha_not_registered"); + } + + // Increase .current_supply that .current_supply > .total_max_supply. + { + auto& ado{m_ados_register.at(asset_position::alpha)}; + + CHECK_AND_ASSERT_EQ(ado.descriptor.current_supply, ado.descriptor.total_max_supply); + ++ado.descriptor.current_supply; + CHECK_AND_ASSERT_GREATER(ado.descriptor.current_supply, ado.descriptor.total_max_supply); + } + + // Alice registers asset ALPH. Transaction is invalid, because .current_supply > .total_max_supply in the asset base descriptor. + { + std::vector sources{}; + std::vector destinations{}; + crypto::secret_key one_time{}; + const auto& ado{m_ados_register.at(asset_position::alpha)}; + const auto& top{blk_1r}; + + success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(2), TESTS_DEFAULT_FEE, 0, sources, destinations); + CHECK_AND_ASSERT_EQ(success, true); + destinations.emplace_back(ado.descriptor.current_supply, alice.get_public_address(), null_pkey); + CHECK_AND_ASSERT_MES(ado.descriptor.current_supply > ado.descriptor.total_max_supply, false, "current_supply <= total_max_supply"); + success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx_1, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); + CHECK_AND_ASSERT_EQ(success, true); + } + + DO_CALLBACK(events, "mark_invalid_tx"); + ADD_CUSTOM_EVENT(events, tx_1); + DO_CALLBACK(events, "assert_asset_alpha_not_registered"); + + // Alice registers asset BETA. In the asset base descriptor .current_supply <= .total_max_supply. Transaction is accepted. + { + std::vector sources{}; + std::vector destinations{}; + crypto::secret_key one_time{}; + const auto& ado{m_ados_register.at(asset_position::beta)}; + const auto& top{blk_1r}; + + success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(2), TESTS_DEFAULT_FEE, 0, sources, destinations); + CHECK_AND_ASSERT_EQ(success, true); + destinations.emplace_back(ado.descriptor.current_supply, alice.get_public_address(), null_pkey); + CHECK_AND_ASSERT(ado.descriptor.current_supply <= ado.descriptor.total_max_supply, false); + success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx_2, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); + CHECK_AND_ASSERT_EQ(success, true); + } + + ADD_CUSTOM_EVENT(events, tx_2); + MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, alice, tx_2); + REWIND_BLOCKS_N(events, blk_2r, blk_2, alice, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + DO_CALLBACK(events, "assert_asset_beta_registered"); + + { + crypto::public_key beta_asset_id{}; + crypto::point_t point_beta_asset_id{}; + + CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(m_ados_register.at(asset_position::beta), &point_beta_asset_id, &beta_asset_id), false, "failed to calculate asset id"); + m_ado_emit.opt_asset_id = beta_asset_id; + } + + CHECK_AND_ASSERT_GREATER(m_ado_emit.descriptor.current_supply, m_ado_emit.descriptor.total_max_supply); + // Alice emits asset BETA. The emission is performed through the wallet object. There is no emission, because .current_supply > .total_max_supply in the asset base descriptor. + DO_CALLBACK(events, "emit_asset_beta_with_incorrect_supply"); + + // Alice emits asset BETA. A transaction is constructed through finalize_tx_param object. This is low-level transaction construction. Transaction is rejected by the core, because .current_supply > + // .total_max_supply in the asset base descriptor. + { + std::vector sources{}; + std::vector destinations{}; + crypto::secret_key one_time{}; + tx_source_entry source{}; + finalize_tx_param ftp{}; + finalized_tx ftx{}; + const auto& top{blk_2r}; + + success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(2), TESTS_DEFAULT_FEE, 0, sources, destinations); + CHECK_AND_ASSERT_EQ(success, true); + CHECK_AND_ASSERT_GREATER(m_ado_emit.descriptor.current_supply, m_ados_register.at(asset_position::beta).descriptor.current_supply); + destinations.emplace_back(m_ado_emit.descriptor.current_supply - m_ados_register.at(asset_position::beta).descriptor.current_supply, alice.get_public_address(), null_pkey); + ftp.sources = sources; + ftp.prepared_destinations = destinations; + ftp.tx_version = get_tx_version(get_block_height(top), m_hardforks); + ftp.extra = {m_ado_emit}; + ftp.shuffle = true; + CHECK_AND_ASSERT_GREATER(m_ado_emit.descriptor.current_supply, m_ado_emit.descriptor.total_max_supply); + success = construct_tx(alice.get_keys(), ftp, ftx); + CHECK_AND_ASSERT_EQ(success, true); + tx_3 = ftx.tx; + } + + DO_CALLBACK(events, "mark_invalid_tx"); + ADD_CUSTOM_EVENT(events, tx_3); + DO_CALLBACK(events, "assert_asset_beta_not_emitted"); + // Alice burns asset BETA. The public burn is performed through the wallet object. Burn isn't performed, because .current_supply > .total_max_supply in the asset base descriptor. + DO_CALLBACK(events, "public_burn_asset_beta_with_incorrect_supply"); + DO_CALLBACK(events, "assert_alice_final_balance_native_asset"); + + return true; +} + +bool asset_current_and_total_supplies_comparative_constraints::assert_asset_alpha_not_registered(currency::core& c, size_t ev_index, const std::vector& events) const +{ + const std::shared_ptr alice_wallet{init_playtime_test_wallet_t(events, c, ALICE_ACC_IDX)}; + crypto::public_key alpha_asset_id{}; + const std::string ticker{m_ados_register.at(asset_position::alpha).descriptor.ticker}; + + alice_wallet->refresh(); + + { + crypto::point_t point_alpha_asset_id{}; + + CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(m_ados_register.at(asset_position::alpha), &point_alpha_asset_id, &alpha_asset_id), false, "failed to calculate asset " + ticker + " id"); + } + + { + asset_descriptor_base alpha_adb{}; + + CHECK_AND_ASSERT_MES(!c.get_blockchain_storage().get_asset_info(alpha_asset_id, alpha_adb), false, "asset " + ticker + " must not be registered"); + } + + return true; +} + +bool asset_current_and_total_supplies_comparative_constraints::assert_asset_beta_registered(currency::core& c, size_t ev_index, const std::vector& events) const +{ + const std::shared_ptr alice_wallet{init_playtime_test_wallet_t(events, c, ALICE_ACC_IDX)}; + crypto::public_key key_beta_asset_id{}; + const std::string ticker{m_ados_register.at(asset_position::beta).descriptor.ticker}; + + alice_wallet->refresh(); + + { + crypto::point_t point_beta_asset_id{}; + + CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(m_ados_register.at(asset_position::beta), &point_beta_asset_id, &key_beta_asset_id), false, "failed to calculate asset id"); + } + + { + asset_descriptor_base beta_adb{}; + + CHECK_AND_ASSERT_MES(c.get_blockchain_storage().get_asset_info(key_beta_asset_id, beta_adb), false, "asset " + ticker + " must not be registered"); + } + + CHECK_AND_ASSERT_MES(alice_wallet->balance(key_beta_asset_id) == 1, false, "Alice has got not exactly 1 " + ticker); + + return true; +} + +bool asset_current_and_total_supplies_comparative_constraints::emit_asset_beta_with_incorrect_supply(currency::core& c, size_t ev_index, const std::vector& events) const +{ + const std::shared_ptr alice_wallet{init_playtime_test_wallet_t(events, c, ALICE_ACC_IDX)}; + std::vector destinations{}; + crypto::public_key beta_asset_id{}; + + { + asset_descriptor_base adb{}; + CHECK_AND_ASSERT_EQ(c.get_blockchain_storage().get_asset_info(*m_ado_emit.opt_asset_id, adb), true); + } + + { + crypto::point_t point_beta_asset_id{}; + + CHECK_AND_ASSERT_EQ(get_or_calculate_asset_id(m_ado_emit, &point_beta_asset_id, &beta_asset_id), true); + } + + CHECK_AND_ASSERT_EQ(*m_ado_emit.opt_asset_id, beta_asset_id); + alice_wallet->refresh(); + + { + const auto& ado_register{m_ados_register.at(asset_position::beta)}; + + CHECK_AND_ASSERT_GREATER(m_ado_emit.descriptor.current_supply, ado_register.descriptor.current_supply); + destinations.emplace_back(m_ado_emit.descriptor.current_supply - ado_register.descriptor.current_supply, alice_wallet->get_account().get_public_address(), beta_asset_id); + } + + CHECK_AND_ASSERT_GREATER(m_ado_emit.descriptor.current_supply, m_ado_emit.descriptor.total_max_supply); + + try + { + transaction tx{}; + + alice_wallet->emit_asset(beta_asset_id, destinations, tx); + } + catch (const tools::error::tx_rejected&) + { + CHECK_AND_ASSERT_EQ(c.get_pool_transactions_count(), 0); + return true; + } + catch (...) + { + return false; + } + + return false; +} + +bool asset_current_and_total_supplies_comparative_constraints::assert_asset_beta_not_emitted(currency::core& c, size_t ev_index, const std::vector& events) const +{ + const std::shared_ptr alice_wallet{init_playtime_test_wallet_t(events, c, ALICE_ACC_IDX)}; + crypto::public_key beta_asset_id{}; + const auto& register_ado{m_ados_register.at(asset_position::beta)}; + + alice_wallet->refresh(); + + { + crypto::point_t point_beta_asset_id{}; + + CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(register_ado, &point_beta_asset_id, &beta_asset_id), false, "failed to calculate asset id"); + } + + { + const uint64_t& current_supply{register_ado.descriptor.current_supply}; + + CHECK_AND_ASSERT_MES(alice_wallet->balance(beta_asset_id) == current_supply, false, "Alice has got not exactly " + std::to_string(current_supply) + ' ' + register_ado.descriptor.ticker); + } +} + +bool asset_current_and_total_supplies_comparative_constraints::public_burn_asset_beta_with_incorrect_supply(currency::core& c, size_t ev_index, const std::vector& events) const +{ + const std::shared_ptr alice_wallet{init_playtime_test_wallet_t(events, c, ALICE_ACC_IDX)}; + crypto::public_key beta_asset_id{}; + + alice_wallet->refresh(); + + { + crypto::point_t point_beta_asset_id{}; + + CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(m_ados_register.at(asset_position::beta), &point_beta_asset_id, &beta_asset_id), false, "failed to calculate asset id"); + } + + try + { + transaction tx{}; + + alice_wallet->burn_asset(beta_asset_id, m_ado_emit.descriptor.current_supply, tx); + } + catch (const std::runtime_error&) + { + CHECK_AND_ASSERT_EQ(c.get_pool_transactions_count(), 0); + return true; + } + + return false; +} + +bool asset_current_and_total_supplies_comparative_constraints::assert_alice_final_balance_native_asset(currency::core& c, size_t ev_index, const std::vector& events) const +{ + const std::shared_ptr alice_wallet{init_playtime_test_wallet_t(events, c, ALICE_ACC_IDX)}; + + alice_wallet->refresh(); + CHECK_AND_ASSERT_EQ(alice_wallet->balance(currency::native_coin_asset_id), 11'000'000'000'000 + MK_TEST_COINS(2)); + + return true; +} diff --git a/tests/core_tests/multiassets_test.h b/tests/core_tests/multiassets_test.h index 2305b594..687f5956 100644 --- a/tests/core_tests/multiassets_test.h +++ b/tests/core_tests/multiassets_test.h @@ -95,3 +95,22 @@ struct eth_signed_asset_via_rpc : public wallet_test bool generate(std::vector& events) const; bool c1(currency::core& c, size_t ev_index, const std::vector& events); }; + +struct asset_current_and_total_supplies_comparative_constraints : public wallet_test +{ +public: + asset_current_and_total_supplies_comparative_constraints(); + bool generate(std::vector& events) const; + bool assert_asset_alpha_not_registered(currency::core& c, size_t ev_index, const std::vector& events) const; + bool assert_asset_beta_registered(currency::core& c, size_t ev_index, const std::vector& events) const; + bool emit_asset_beta_with_incorrect_supply(currency::core& c, size_t ev_index, const std::vector& events) const; + bool assert_asset_beta_not_emitted(currency::core& c, size_t ev_index, const std::vector& events) const; + bool public_burn_asset_beta_with_incorrect_supply(currency::core& c, size_t ev_index, const std::vector& events) const; + bool assert_alice_final_balance_native_asset(currency::core& c, size_t ev_index, const std::vector& events) const; + +private: + enum asset_position { alpha = 0, beta = 1 }; + mutable std::array m_adbs{}; + mutable std::array m_ados_register{}; + mutable currency::asset_descriptor_operation m_ado_emit{}; +}; From cf8004050ccc1fca417e199a0e887cdb099a97f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=D1=91pa=20Dolgorukov?= Date: Thu, 10 Oct 2024 18:10:25 +0500 Subject: [PATCH 09/10] coretests: correct the test "asset_current_and_total_supplies_comparative_constraints" (#468) * Coretests: implement the test "asset_current_and_total_supplies_comparative_constraints" * Core tests: correct the test "asset_current_and_total_supplies_comparative_constraints" --- tests/core_tests/multiassets_test.cpp | 126 ++++++++++++++++---------- tests/core_tests/multiassets_test.h | 8 +- 2 files changed, 80 insertions(+), 54 deletions(-) diff --git a/tests/core_tests/multiassets_test.cpp b/tests/core_tests/multiassets_test.cpp index 58b047b4..ddf9a1fe 100644 --- a/tests/core_tests/multiassets_test.cpp +++ b/tests/core_tests/multiassets_test.cpp @@ -1957,46 +1957,59 @@ asset_current_and_total_supplies_comparative_constraints::asset_current_and_tota { { auto& adb{m_adbs.at(asset_position::alpha)}; + adb.full_name = "Alpha"; adb.ticker = "ALPH"; - adb.current_supply = adb.total_max_supply = 0; + adb.current_supply = 1; + adb.total_max_supply = 0; } { auto& adb{m_adbs.at(asset_position::beta)}; + adb.full_name = "Beta"; adb.ticker = "BETA"; adb.current_supply = adb.total_max_supply = 1; } - m_ados_register.at(asset_position::alpha).operation_type = ASSET_DESCRIPTOR_OPERATION_REGISTER; - m_ados_register.at(asset_position::beta).operation_type = ASSET_DESCRIPTOR_OPERATION_REGISTER; + { + auto &adb{m_adbs.at(asset_position::gamma)}; + + adb.full_name = "Gamma"; + adb.ticker = "GAMM"; + adb.current_supply = adb.total_max_supply = 0; + } + + m_ados_register.at(asset_position::alpha).operation_type = m_ados_register.at(asset_position::beta).operation_type = m_ados_register.at(asset_position::gamma).operation_type = + ASSET_DESCRIPTOR_OPERATION_REGISTER; + m_ado_emit.operation_type = ASSET_DESCRIPTOR_OPERATION_EMIT; + REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_asset_gamma_registered); REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_asset_alpha_not_registered); REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_asset_beta_registered); REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, emit_asset_beta_with_incorrect_supply); REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_asset_beta_not_emitted); REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, public_burn_asset_beta_with_incorrect_supply); - REGISTER_CALLBACK_METHOD(asset_current_and_total_supplies_comparative_constraints, assert_alice_final_balance_native_asset); } bool asset_current_and_total_supplies_comparative_constraints::generate(std::vector& events) const { /* Test ideas: - * ensure that it's impossible to register asset with .current_supply = .total_max_supply = 0; - * ensure that asset operations in which .current_supply is greater than .total_max_supply are not performed. */ + * ensure that it's possible to register asset with .current_supply = .total_max_supply = 0; + * ensure that asset operations in which .current_supply is greater than .total_max_supply are not performed. */ bool success{}; GENERATE_ACCOUNT(miner); GENERATE_ACCOUNT(alice); - transaction tx_0{}, tx_1{}, tx_2{}, tx_3{}; + transaction tx_0{}, tx_1{}, tx_2{}, tx_3{}, tx_4{}; m_accounts.push_back(miner); m_accounts.push_back(alice); - m_adbs.at(asset_position::alpha).owner = m_adbs.at(asset_position::beta).owner = alice.get_public_address().spend_public_key; + m_adbs.at(asset_position::alpha).owner = m_adbs.at(asset_position::beta).owner = m_adbs.at(asset_position::gamma).owner = alice.get_public_address().spend_public_key; m_ados_register.at(asset_position::alpha).descriptor = m_adbs.at(asset_position::alpha); m_ados_register.at(asset_position::beta).descriptor = m_ado_emit.descriptor = m_adbs.at(asset_position::beta); + m_ados_register.at(asset_position::gamma).descriptor = m_adbs.at(asset_position::gamma); CHECK_AND_ASSERT(m_ado_emit.descriptor.current_supply <= m_ado_emit.descriptor.total_max_supply, false); ++m_ado_emit.descriptor.current_supply; CHECK_AND_ASSERT(m_ado_emit.descriptor.current_supply > m_ado_emit.descriptor.total_max_supply, false); @@ -2006,12 +2019,13 @@ bool asset_current_and_total_supplies_comparative_constraints::generate(std::vec REWIND_BLOCKS_N(events, blk_0r, blk_0, miner, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); { + const auto& top{blk_0r}; std::vector sources{}; std::vector destinations{}; - success = fill_tx_sources_and_destinations(events, blk_0r, miner.get_keys(), alice.get_public_address(), MK_TEST_COINS(3), TESTS_DEFAULT_FEE, 0, sources, destinations); + success = fill_tx_sources_and_destinations(events, top, miner.get_keys(), alice.get_public_address(), MK_TEST_COINS(8), TESTS_DEFAULT_FEE, 0, sources, destinations); CHECK_AND_ASSERT_EQ(success, true); - success = construct_tx(miner.get_keys(), sources, destinations, empty_attachment, tx_0, get_tx_version(get_block_height(blk_0r), m_hardforks), 0); + success = construct_tx(miner.get_keys(), sources, destinations, empty_attachment, tx_0, get_tx_version(get_block_height(top), m_hardforks), 0); CHECK_AND_ASSERT_EQ(success, true); } @@ -2019,75 +2033,71 @@ bool asset_current_and_total_supplies_comparative_constraints::generate(std::vec MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner, tx_0); REWIND_BLOCKS_N(events, blk_1r, blk_1, miner, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); - // Alice registers asset ALPH. Transaction is invalid, because .current_supply = 0, .total_max_supply = 0 in the asset base descriptor. - if (const auto& top{blk_1r}; m_hardforks.is_hardfork_active_for_height(ZANO_HARDFORK_05, get_block_height(top))) + // Alice registers the asset GAMM with .current_supply = 0, .total_max_supply = 0. { + const auto& top{blk_1r}; std::vector sources{}; std::vector destinations{}; - const auto& ado{m_ados_register.at(asset_position::alpha)}; - transaction tx{}; + const auto& ado{m_ados_register.at(asset_position::gamma)}; crypto::secret_key one_time{}; - success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(3), TESTS_DEFAULT_FEE, 0, sources, destinations); + success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(2), TESTS_DEFAULT_FEE, 0, sources, destinations); CHECK_AND_ASSERT_EQ(success, true); destinations.emplace_back(ado.descriptor.current_supply, alice.get_public_address(), null_pkey); CHECK_AND_ASSERT_EQ(ado.descriptor.total_max_supply, 0); CHECK_AND_ASSERT_EQ(ado.descriptor.total_max_supply, ado.descriptor.current_supply); - success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); + success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx_1, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); CHECK_AND_ASSERT_EQ(success, true); - DO_CALLBACK(events, "mark_invalid_tx"); - ADD_CUSTOM_EVENT(events, tx); - DO_CALLBACK(events, "assert_asset_alpha_not_registered"); } - // Increase .current_supply that .current_supply > .total_max_supply. - { - auto& ado{m_ados_register.at(asset_position::alpha)}; - - CHECK_AND_ASSERT_EQ(ado.descriptor.current_supply, ado.descriptor.total_max_supply); - ++ado.descriptor.current_supply; - CHECK_AND_ASSERT_GREATER(ado.descriptor.current_supply, ado.descriptor.total_max_supply); - } + // tx_1 is valid and must be accepted. + ADD_CUSTOM_EVENT(events, tx_1); + MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, alice, tx_1); + REWIND_BLOCKS_N(events, blk_2r, blk_2, alice, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + DO_CALLBACK(events, "assert_asset_gamma_registered"); // Alice registers asset ALPH. Transaction is invalid, because .current_supply > .total_max_supply in the asset base descriptor. { + const auto& top{blk_2r}; std::vector sources{}; std::vector destinations{}; crypto::secret_key one_time{}; const auto& ado{m_ados_register.at(asset_position::alpha)}; - const auto& top{blk_1r}; success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(2), TESTS_DEFAULT_FEE, 0, sources, destinations); CHECK_AND_ASSERT_EQ(success, true); destinations.emplace_back(ado.descriptor.current_supply, alice.get_public_address(), null_pkey); CHECK_AND_ASSERT_MES(ado.descriptor.current_supply > ado.descriptor.total_max_supply, false, "current_supply <= total_max_supply"); - success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx_1, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); + success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx_2, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); CHECK_AND_ASSERT_EQ(success, true); } + /* TODO: tx_1 is invalid and mustn't be accepted. DO_CALLBACK(events, "mark_invalid_tx"); - ADD_CUSTOM_EVENT(events, tx_1); - DO_CALLBACK(events, "assert_asset_alpha_not_registered"); + ADD_CUSTOM_EVENT(events, tx_2); + DO_CALLBACK(events, "assert_asset_alpha_not_registered"); */ - // Alice registers asset BETA. In the asset base descriptor .current_supply <= .total_max_supply. Transaction is accepted. + // Alice registers asset BETA. In the asset base descriptor .current_supply <= .total_max_supply. { + const auto& top{blk_2r}; + std::vector sources{}; std::vector destinations{}; crypto::secret_key one_time{}; const auto& ado{m_ados_register.at(asset_position::beta)}; - const auto& top{blk_1r}; success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(2), TESTS_DEFAULT_FEE, 0, sources, destinations); CHECK_AND_ASSERT_EQ(success, true); destinations.emplace_back(ado.descriptor.current_supply, alice.get_public_address(), null_pkey); CHECK_AND_ASSERT(ado.descriptor.current_supply <= ado.descriptor.total_max_supply, false); - success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx_2, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); + success = construct_tx(alice.get_keys(), sources, destinations, {ado}, empty_attachment, tx_3, get_tx_version(get_block_height(top), m_hardforks), one_time, 0); CHECK_AND_ASSERT_EQ(success, true); } - ADD_CUSTOM_EVENT(events, tx_2); - MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, alice, tx_2); - REWIND_BLOCKS_N(events, blk_2r, blk_2, alice, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + // tx_3 is valid and must be accepted. + ADD_CUSTOM_EVENT(events, tx_3); + MAKE_NEXT_BLOCK_TX1(events, blk_3, blk_2r, alice, tx_3); + REWIND_BLOCKS_N(events, blk_3r, blk_3, alice, CURRENCY_MINED_MONEY_UNLOCK_WINDOW); DO_CALLBACK(events, "assert_asset_beta_registered"); { @@ -2102,21 +2112,23 @@ bool asset_current_and_total_supplies_comparative_constraints::generate(std::vec // Alice emits asset BETA. The emission is performed through the wallet object. There is no emission, because .current_supply > .total_max_supply in the asset base descriptor. DO_CALLBACK(events, "emit_asset_beta_with_incorrect_supply"); - // Alice emits asset BETA. A transaction is constructed through finalize_tx_param object. This is low-level transaction construction. Transaction is rejected by the core, because .current_supply > - // .total_max_supply in the asset base descriptor. + /* Alice emits asset BETA. A transaction is constructed through finalize_tx_param object. This is low-level transaction construction. Transaction muse be rejected by the core, because + .current_supply > .total_max_supply in the asset base descriptor. */ { + const auto& top{blk_3r}; + const auto& ado_register{m_ados_register.at(asset_position::beta)}; std::vector sources{}; std::vector destinations{}; crypto::secret_key one_time{}; tx_source_entry source{}; finalize_tx_param ftp{}; finalized_tx ftx{}; - const auto& top{blk_2r}; success = fill_tx_sources_and_destinations(events, top, alice.get_keys(), alice.get_public_address(), MK_TEST_COINS(2), TESTS_DEFAULT_FEE, 0, sources, destinations); CHECK_AND_ASSERT_EQ(success, true); - CHECK_AND_ASSERT_GREATER(m_ado_emit.descriptor.current_supply, m_ados_register.at(asset_position::beta).descriptor.current_supply); - destinations.emplace_back(m_ado_emit.descriptor.current_supply - m_ados_register.at(asset_position::beta).descriptor.current_supply, alice.get_public_address(), null_pkey); + CHECK_AND_ASSERT_GREATER(m_ado_emit.descriptor.current_supply, ado_register.descriptor.current_supply); + destinations.emplace_back(m_ado_emit.descriptor.current_supply - ado_register.descriptor.current_supply, alice.get_public_address(), null_pkey); + ftp.sources = sources; ftp.prepared_destinations = destinations; ftp.tx_version = get_tx_version(get_block_height(top), m_hardforks); @@ -2125,15 +2137,14 @@ bool asset_current_and_total_supplies_comparative_constraints::generate(std::vec CHECK_AND_ASSERT_GREATER(m_ado_emit.descriptor.current_supply, m_ado_emit.descriptor.total_max_supply); success = construct_tx(alice.get_keys(), ftp, ftx); CHECK_AND_ASSERT_EQ(success, true); - tx_3 = ftx.tx; + tx_4 = ftx.tx; } DO_CALLBACK(events, "mark_invalid_tx"); - ADD_CUSTOM_EVENT(events, tx_3); + ADD_CUSTOM_EVENT(events, tx_4); DO_CALLBACK(events, "assert_asset_beta_not_emitted"); - // Alice burns asset BETA. The public burn is performed through the wallet object. Burn isn't performed, because .current_supply > .total_max_supply in the asset base descriptor. + // Alice burns asset BETA. The public burn is performed through the wallet object. Burn mustn't be performed, because .current_supply > .total_max_supply in the asset base descriptor. DO_CALLBACK(events, "public_burn_asset_beta_with_incorrect_supply"); - DO_CALLBACK(events, "assert_alice_final_balance_native_asset"); return true; } @@ -2155,7 +2166,7 @@ bool asset_current_and_total_supplies_comparative_constraints::assert_asset_alph { asset_descriptor_base alpha_adb{}; - CHECK_AND_ASSERT_MES(!c.get_blockchain_storage().get_asset_info(alpha_asset_id, alpha_adb), false, "asset " + ticker + " must not be registered"); + CHECK_AND_ASSERT_MES(!c.get_blockchain_storage().get_asset_info(alpha_asset_id, alpha_adb), false, "the asset " + ticker + " must not be registered"); } return true; @@ -2178,7 +2189,7 @@ bool asset_current_and_total_supplies_comparative_constraints::assert_asset_beta { asset_descriptor_base beta_adb{}; - CHECK_AND_ASSERT_MES(c.get_blockchain_storage().get_asset_info(key_beta_asset_id, beta_adb), false, "asset " + ticker + " must not be registered"); + CHECK_AND_ASSERT_MES(c.get_blockchain_storage().get_asset_info(key_beta_asset_id, beta_adb), false, "the asset " + ticker + " must not be registered"); } CHECK_AND_ASSERT_MES(alice_wallet->balance(key_beta_asset_id) == 1, false, "Alice has got not exactly 1 " + ticker); @@ -2283,12 +2294,27 @@ bool asset_current_and_total_supplies_comparative_constraints::public_burn_asset return false; } -bool asset_current_and_total_supplies_comparative_constraints::assert_alice_final_balance_native_asset(currency::core& c, size_t ev_index, const std::vector& events) const +bool asset_current_and_total_supplies_comparative_constraints::assert_asset_gamma_registered(currency::core& c, size_t ev_index, const std::vector& events) const { const std::shared_ptr alice_wallet{init_playtime_test_wallet_t(events, c, ALICE_ACC_IDX)}; + crypto::public_key key_gamma_asset_id{}; + const std::string ticker{m_ados_register.at(asset_position::gamma).descriptor.ticker}; alice_wallet->refresh(); - CHECK_AND_ASSERT_EQ(alice_wallet->balance(currency::native_coin_asset_id), 11'000'000'000'000 + MK_TEST_COINS(2)); + + { + crypto::point_t point_gamma_asset_id{}; + + CHECK_AND_ASSERT_MES(get_or_calculate_asset_id(m_ados_register.at(asset_position::gamma), &point_gamma_asset_id, &key_gamma_asset_id), false, "failed to calculate asset " + ticker + " id"); + } + + { + asset_descriptor_base gamma_adb{}; + + CHECK_AND_ASSERT_MES(c.get_blockchain_storage().get_asset_info(key_gamma_asset_id, gamma_adb), false, "the asset " + ticker + " must be registered"); + } + + CHECK_AND_ASSERT_EQ(alice_wallet->balance(key_gamma_asset_id), m_ados_register.at(asset_position::gamma).descriptor.current_supply); return true; } diff --git a/tests/core_tests/multiassets_test.h b/tests/core_tests/multiassets_test.h index 687f5956..c82e00f3 100644 --- a/tests/core_tests/multiassets_test.h +++ b/tests/core_tests/multiassets_test.h @@ -106,11 +106,11 @@ public: bool emit_asset_beta_with_incorrect_supply(currency::core& c, size_t ev_index, const std::vector& events) const; bool assert_asset_beta_not_emitted(currency::core& c, size_t ev_index, const std::vector& events) const; bool public_burn_asset_beta_with_incorrect_supply(currency::core& c, size_t ev_index, const std::vector& events) const; - bool assert_alice_final_balance_native_asset(currency::core& c, size_t ev_index, const std::vector& events) const; + bool assert_asset_gamma_registered(currency::core& c, size_t ev_index, const std::vector& events) const; private: - enum asset_position { alpha = 0, beta = 1 }; - mutable std::array m_adbs{}; - mutable std::array m_ados_register{}; + enum asset_position { alpha = 0, beta = 1, gamma = 2 }; + mutable std::array m_adbs{}; + mutable std::array m_ados_register{}; mutable currency::asset_descriptor_operation m_ado_emit{}; }; From e58b20ae5b62745513b8451af1ae195c9c6a8e20 Mon Sep 17 00:00:00 2001 From: sowle Date: Thu, 10 Oct 2024 19:11:30 +0200 Subject: [PATCH 10/10] coretests: test asset_current_and_total_supplies_comparative_constraints was temporary disabled --- tests/core_tests/chaingen_main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp index cc4a8e17..b70070a8 100644 --- a/tests/core_tests/chaingen_main.cpp +++ b/tests/core_tests/chaingen_main.cpp @@ -1296,7 +1296,7 @@ int main(int argc, char* argv[]) GENERATE_AND_PLAY_HF(asset_operation_and_hardfork_checks, "4-*"); GENERATE_AND_PLAY_HF(eth_signed_asset_basics, "5-*"); // TODO: make HF4 version GENERATE_AND_PLAY_HF(eth_signed_asset_via_rpc, "5-*"); // TODO: make HF4 version - GENERATE_AND_PLAY_HF(asset_current_and_total_supplies_comparative_constraints, "4-*"); + //GENERATE_AND_PLAY_HF(asset_current_and_total_supplies_comparative_constraints, "4-*"); <-- temporary disabled, waiting for Stepan's fix -- sowle GENERATE_AND_PLAY_HF(pos_fuse_test, "4-*");