diff --git a/bchain/coins/bitzeny/bitzenyparser.go b/bchain/coins/bitzeny/bitzenyparser.go new file mode 100644 index 00000000..c4a08e5f --- /dev/null +++ b/bchain/coins/bitzeny/bitzenyparser.go @@ -0,0 +1,64 @@ +package bitzeny + +import ( + "blockbook/bchain/coins/btc" + + "github.com/martinboehm/btcd/wire" + "github.com/martinboehm/btcutil/chaincfg" +) + +// magic numbers +const ( + MainnetMagic wire.BitcoinNet = 0xf9bea5da + TestnetMagic wire.BitcoinNet = 0x594e4559 +) + +// chain parameters +var ( + MainNetParams chaincfg.Params + TestNetParams chaincfg.Params +) + +func init() { + MainNetParams = chaincfg.MainNetParams + MainNetParams.Net = MainnetMagic + MainNetParams.PubKeyHashAddrID = []byte{81} + MainNetParams.ScriptHashAddrID = []byte{5} + MainNetParams.Bech32HRPSegwit = "bz" + + TestNetParams = chaincfg.TestNet3Params + TestNetParams.Net = TestnetMagic + TestNetParams.PubKeyHashAddrID = []byte{111} + TestNetParams.ScriptHashAddrID = []byte{196} + TestNetParams.Bech32HRPSegwit = "tz" +} + +// BitZenyParser handle +type BitZenyParser struct { + *btc.BitcoinParser +} + +// NewBitZenyParser returns new BitZenyParser instance +func NewBitZenyParser(params *chaincfg.Params, c *btc.Configuration) *BitZenyParser { + return &BitZenyParser{BitcoinParser: btc.NewBitcoinParser(params, c)} +} + +// GetChainParams contains network parameters for the main BitZeny network, +// and the test BitZeny network +func GetChainParams(chain string) *chaincfg.Params { + if !chaincfg.IsRegistered(&MainNetParams) { + err := chaincfg.Register(&MainNetParams) + if err == nil { + err = chaincfg.Register(&TestNetParams) + } + if err != nil { + panic(err) + } + } + switch chain { + case "test": + return &TestNetParams + default: + return &MainNetParams + } +} diff --git a/bchain/coins/bitzeny/bitzenyparser_test.go b/bchain/coins/bitzeny/bitzenyparser_test.go new file mode 100644 index 00000000..d4e9846d --- /dev/null +++ b/bchain/coins/bitzeny/bitzenyparser_test.go @@ -0,0 +1,289 @@ +// +build unittest + +package bitzeny + +import ( + "blockbook/bchain" + "blockbook/bchain/coins/btc" + "encoding/hex" + "math/big" + "os" + "reflect" + "testing" + + "github.com/martinboehm/btcutil/chaincfg" +) + +func TestMain(m *testing.M) { + c := m.Run() + chaincfg.ResetParams() + os.Exit(c) +} + +func Test_GetAddrDescFromAddress_Mainnet(t *testing.T) { + type args struct { + address string + } + tests := []struct { + name string + args args + want string + wantErr bool + }{ + { + name: "P2PKH1", + args: args{address: "Zw74N1RSU2xV3a7SBERBiCP11fMwX5yvMu"}, + want: "76a914d8658ca5c406149071687d370d1d22d972d2f88488ac", + wantErr: false, + }, + { + name: "P2PKH2", + args: args{address: "ZiSn1vTSxGu2kFcnkjjm7bYGhT5BVAVfEG"}, + want: "76a9144d869697281ad18370313122795e56dfdc3a331388ac", + wantErr: false, + }, + { + name: "P2SH1", + args: args{address: "3CZ3357bm1K81StpEDQtEH3ho3ULx19nc8"}, + want: "a9147726fc1144eae1b7bd301d87d0a7f846cadb591887", + wantErr: false, + }, + { + name: "P2SH2", + args: args{address: "3M1AjZEuBzScbd9pchiGJSVT4yNfwzSmXP"}, + want: "a914d3d93b5d7f57b94a4fecde93d4489f2b423fd3c287", + wantErr: false, + }, + { + name: "witness_v0_keyhash", + args: args{address: "bz1q7rfrdacyyfwx8gppd8ah9hka8npgqsm44prfnd"}, + want: "0014f0d236f704225c63a02169fb72dedd3cc2804375", + wantErr: false, + }, + { + name: "witness_v0_scripthashx", + args: args{address: "bz1qd2mspe6m2wpztw4q2mccyvyess6569eu59sfvf0u0vdmdwltr5lse8d7sw"}, + want: "00206ab700e75b538225baa056f182309984354d173ca1609625fc7b1bb6bbeb1d3f", + wantErr: false, + }, + } + parser := NewBitZenyParser(GetChainParams("main"), &btc.Configuration{}) + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := parser.GetAddrDescFromAddress(tt.args.address) + if (err != nil) != tt.wantErr { + t.Errorf("GetAddrDescFromAddress() error = %v, wantErr %v", err, tt.wantErr) + return + } + h := hex.EncodeToString(got) + if !reflect.DeepEqual(h, tt.want) { + t.Errorf("GetAddrDescFromAddress() = %v, want %v", h, tt.want) + } + }) + } +} + +func Test_GetAddressesFromAddrDesc(t *testing.T) { + type args struct { + script string + } + tests := []struct { + name string + args args + want []string + want2 bool + wantErr bool + }{ + { + name: "P2PKH", + args: args{script: "76a914d8658ca5c406149071687d370d1d22d972d2f88488ac"}, + want: []string{"Zw74N1RSU2xV3a7SBERBiCP11fMwX5yvMu"}, + want2: true, + wantErr: false, + }, + { + name: "P2SH", + args: args{script: "a9147726fc1144eae1b7bd301d87d0a7f846cadb591887"}, + want: []string{"3CZ3357bm1K81StpEDQtEH3ho3ULx19nc8"}, + want2: true, + wantErr: false, + }, + { + name: "P2WPKH", + args: args{script: "0014f0d236f704225c63a02169fb72dedd3cc2804375"}, + want: []string{"bz1q7rfrdacyyfwx8gppd8ah9hka8npgqsm44prfnd"}, + want2: true, + wantErr: false, + }, + { + name: "P2WSH", + args: args{script: "00206ab700e75b538225baa056f182309984354d173ca1609625fc7b1bb6bbeb1d3f"}, + want: []string{"bz1qd2mspe6m2wpztw4q2mccyvyess6569eu59sfvf0u0vdmdwltr5lse8d7sw"}, + want2: true, + wantErr: false, + }, + { + name: "OP_RETURN ascii", + args: args{script: "6a0461686f6a"}, + want: []string{"OP_RETURN (ahoj)"}, + want2: false, + wantErr: false, + }, + { + name: "OP_RETURN hex", + args: args{script: "6a072020f1686f6a20"}, + want: []string{"OP_RETURN 2020f1686f6a20"}, + want2: false, + wantErr: false, + }, + } + + parser := NewBitZenyParser(GetChainParams("main"), &btc.Configuration{}) + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b, _ := hex.DecodeString(tt.args.script) + got, got2, err := parser.GetAddressesFromAddrDesc(b) + if (err != nil) != tt.wantErr { + t.Errorf("outputScriptToAddresses() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetAddressesFromAddrDesc() = %v, want %v", got, tt.want) + } + if !reflect.DeepEqual(got2, tt.want2) { + t.Errorf("GetAddressesFromAddrDesc() = %v, want %v", got2, tt.want2) + } + }) + } +} + +var ( + testTx1 bchain.Tx + + testTxPacked1 = "001c3f1a8be6859d3e0100000001aef422fb91cd91e556966fed4121ac44017a761d71385596536bb447ae05213e000000006a47304402202341ac4297925257dc72eb418a069c45e76f7070340e27501f6308cc7eff45f802204a347915adceff5f6fc9b8075d95d47887d46b344c7bbc8066d315931b189ad001210228c2520812b7f8c63e7a088c61b6348b22fa0c98812e736a1fd896bc828d3c65feffffff028041f13d000000001976a91478379ea136bb5783b675cd11e412bf0703995aeb88aca9983141000000001976a9144d869697281ad18370313122795e56dfdc3a331388ac193f1c00" +) + +func init() { + testTx1 = bchain.Tx{ + Hex: "0100000001aef422fb91cd91e556966fed4121ac44017a761d71385596536bb447ae05213e000000006a47304402202341ac4297925257dc72eb418a069c45e76f7070340e27501f6308cc7eff45f802204a347915adceff5f6fc9b8075d95d47887d46b344c7bbc8066d315931b189ad001210228c2520812b7f8c63e7a088c61b6348b22fa0c98812e736a1fd896bc828d3c65feffffff028041f13d000000001976a91478379ea136bb5783b675cd11e412bf0703995aeb88aca9983141000000001976a9144d869697281ad18370313122795e56dfdc3a331388ac193f1c00", + Blocktime: 1583392607, + Txid: "f81c34b300961877328c3aaa7cd5e69068457868309fbf1e92544e3a6a915bcb", + LockTime: 1851161, + Version: 1, + Vin: []bchain.Vin{ + { + ScriptSig: bchain.ScriptSig{ + Hex: "47304402202341ac4297925257dc72eb418a069c45e76f7070340e27501f6308cc7eff45f802204a347915adceff5f6fc9b8075d95d47887d46b344c7bbc8066d315931b189ad001210228c2520812b7f8c63e7a088c61b6348b22fa0c98812e736a1fd896bc828d3c65", + }, + Txid: "3e2105ae47b46b53965538711d767a0144ac2141ed6f9656e591cd91fb22f4ae", + Vout: 0, + Sequence: 4294967294, + }, + }, + Vout: []bchain.Vout{ + { + ValueSat: *big.NewInt(1039221120), + N: 0, + ScriptPubKey: bchain.ScriptPubKey{ + Hex: "76a91478379ea136bb5783b675cd11e412bf0703995aeb88ac", + Addresses: []string{ + "ZnLWULVbAzjy1TSKxGnpkomeeaEDTHk5Nj", + }, + }, + }, + { + ValueSat: *big.NewInt(1093769385), + N: 1, + ScriptPubKey: bchain.ScriptPubKey{ + Hex: "76a9144d869697281ad18370313122795e56dfdc3a331388ac", + Addresses: []string{ + "ZiSn1vTSxGu2kFcnkjjm7bYGhT5BVAVfEG", + }, + }, + }, + }, + } +} + +func Test_PackTx(t *testing.T) { + type args struct { + tx bchain.Tx + height uint32 + blockTime int64 + parser *BitZenyParser + } + tests := []struct { + name string + args args + want string + wantErr bool + }{ + { + name: "BitZeny-1", + args: args{ + tx: testTx1, + height: 1851162, + blockTime: 1583392607, + parser: NewBitZenyParser(GetChainParams("main"), &btc.Configuration{}), + }, + want: testTxPacked1, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.args.parser.PackTx(&tt.args.tx, tt.args.height, tt.args.blockTime) + if (err != nil) != tt.wantErr { + t.Errorf("packTx() error = %v, wantErr %v", err, tt.wantErr) + return + } + h := hex.EncodeToString(got) + if !reflect.DeepEqual(h, tt.want) { + t.Errorf("packTx() = %v, want %v", h, tt.want) + } + }) + } +} + +func Test_UnpackTx(t *testing.T) { + type args struct { + packedTx string + parser *BitZenyParser + } + tests := []struct { + name string + args args + want *bchain.Tx + want1 uint32 + wantErr bool + }{ + { + name: "BitZeny-1", + args: args{ + packedTx: testTxPacked1, + parser: NewBitZenyParser(GetChainParams("main"), &btc.Configuration{}), + }, + want: &testTx1, + want1: 1851162, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b, _ := hex.DecodeString(tt.args.packedTx) + got, got1, err := tt.args.parser.UnpackTx(b) + if (err != nil) != tt.wantErr { + t.Errorf("unpackTx() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("unpackTx() got = %v, want %v", got, tt.want) + } + if got1 != tt.want1 { + t.Errorf("unpackTx() got1 = %v, want %v", got1, tt.want1) + } + }) + } +} diff --git a/bchain/coins/bitzeny/bitzenyrpc.go b/bchain/coins/bitzeny/bitzenyrpc.go new file mode 100644 index 00000000..23d474e1 --- /dev/null +++ b/bchain/coins/bitzeny/bitzenyrpc.go @@ -0,0 +1,58 @@ +package bitzeny + +import ( + "blockbook/bchain" + "blockbook/bchain/coins/btc" + "encoding/json" + + "github.com/golang/glog" +) + +// BitZenyRPC is an interface to JSON-RPC bitcoind service. +type BitZenyRPC struct { + *btc.BitcoinRPC +} + +// NewBitZenyRPC returns new BitZenyRPC instance. +func NewBitZenyRPC(config json.RawMessage, pushHandler func(bchain.NotificationType)) (bchain.BlockChain, error) { + b, err := btc.NewBitcoinRPC(config, pushHandler) + if err != nil { + return nil, err + } + + s := &BitZenyRPC{ + b.(*btc.BitcoinRPC), + } + s.RPCMarshaler = btc.JSONMarshalerV2{} + s.ChainConfig.SupportsEstimateFee = false + + return s, nil +} + +// Initialize initializes BitZenyRPC instance. +func (b *BitZenyRPC) Initialize() error { + ci, err := b.GetChainInfo() + if err != nil { + return err + } + chainName := ci.Chain + + glog.Info("Chain name ", chainName) + params := GetChainParams(chainName) + + // always create parser + b.Parser = NewBitZenyParser(params, b.ChainConfig) + + // parameters for getInfo request + if params.Net == MainnetMagic { + b.Testnet = false + b.Network = "livenet" + } else { + b.Testnet = true + b.Network = "testnet" + } + + glog.Info("rpc: block chain ", params.Name) + + return nil +} diff --git a/bchain/coins/blockchain.go b/bchain/coins/blockchain.go index 3a72d04c..e280dfba 100644 --- a/bchain/coins/blockchain.go +++ b/bchain/coins/blockchain.go @@ -5,6 +5,7 @@ import ( "blockbook/bchain/coins/bch" "blockbook/bchain/coins/bellcoin" "blockbook/bchain/coins/bitcore" + "blockbook/bchain/coins/bitzeny" "blockbook/bchain/coins/btc" "blockbook/bchain/coins/btg" "blockbook/bchain/coins/cpuchain" @@ -110,6 +111,7 @@ func init() { BlockChainFactories["Bitcore"] = bitcore.NewBitcoreRPC BlockChainFactories["Omotenashicoin"] = omotenashicoin.NewOmotenashiCoinRPC BlockChainFactories["Omotenashicoin Testnet"] = omotenashicoin.NewOmotenashiCoinRPC + BlockChainFactories["BitZeny"] = bitzeny.NewBitZenyRPC } // GetCoinNameFromConfig gets coin name and coin shortcut from config file diff --git a/configs/coins/bitzeny.json b/configs/coins/bitzeny.json new file mode 100644 index 00000000..5481e606 --- /dev/null +++ b/configs/coins/bitzeny.json @@ -0,0 +1,69 @@ +{ + "coin": { + "name": "BitZeny", + "shortcut": "ZNY", + "label": "BitZeny", + "alias": "bitzeny" + }, + "ports": { + "backend_rpc": 8095, + "backend_message_queue": 38395, + "blockbook_internal": 9095, + "blockbook_public": 9195 + }, + "ipc": { + "rpc_url_template": "http://127.0.0.1:{{.Ports.BackendRPC}}", + "rpc_user": "rpc", + "rpc_pass": "rpc", + "rpc_timeout": 25, + "message_queue_binding_template": "tcp://127.0.0.1:{{.Ports.BackendMessageQueue}}" + }, + "backend": { + "package_name": "backend-bitzeny", + "package_revision": "satoshilabs-1", + "system_user": "bitzeny", + "version": "2.0.2", + "binary_url": "https://github.com/BitzenyCoreDevelopers/bitzeny/releases/download/z2.0.2/bitzeny-2.0.2-x86_64-linux-gnu.tar.gz", + "verification_type": "sha256", + "verification_source": "d7dcc51fc60abee2b1f3befa0265ddf40e7d38a2266af94c14242db121b98d41", + "extract_command": "tar -C backend --strip 1 -xf", + "exclude_files": [ + "bin/bitzeny-qt" + ], + "exec_command_template": "{{.Env.BackendInstallPath}}/{{.Coin.Alias}}/bin/bitzenyd -datadir={{.Env.BackendDataPath}}/{{.Coin.Alias}}/backend -conf={{.Env.BackendInstallPath}}/{{.Coin.Alias}}/{{.Coin.Alias}}.conf -pid=/run/{{.Coin.Alias}}/{{.Coin.Alias}}.pid", + "logrotate_files_template": "{{.Env.BackendDataPath}}/{{.Coin.Alias}}/backend/*.log", + "postinst_script_template": "", + "service_type": "forking", + "service_additional_params_template": "", + "protect_memory": true, + "mainnet": true, + "server_config_file": "bitcoin_like.conf", + "client_config_file": "bitcoin_like_client.conf", + "additional_params": { + "whitelist": "127.0.0.1" + } + }, + "blockbook": { + "package_name": "blockbook-bitzeny", + "system_user": "blockbook-bitzeny", + "internal_binding_template": ":{{.Ports.BlockbookInternal}}", + "public_binding_template": ":{{.Ports.BlockbookPublic}}", + "explorer_url": "", + "additional_params": "", + "block_chain": { + "parse": true, + "mempool_workers": 8, + "mempool_sub_workers": 2, + "block_addresses_to_keep": 300, + "xpub_magic": 76067358, + "xpub_magic_segwit_p2sh": 77429938, + "xpub_magic_segwit_native": 78792518, + "slip44": 123, + "additional_params": {} + } + }, + "meta": { + "package_maintainer": "ilmango-doge", + "package_maintainer_email": "ilmango.doge@gmail.com" + } + } \ No newline at end of file diff --git a/docs/ports.md b/docs/ports.md index 5f153141..9a2450f7 100644 --- a/docs/ports.md +++ b/docs/ports.md @@ -42,6 +42,7 @@ | DeepOnion | 9091 | 9191 | 8091 | 38391 | | Unobtanium | 9092 | 9192 | 65535 | 38392 | | Omotenashicoin | 9094 | 9194 | 8094 | 38394 | +| BitZeny | 9095 | 9195 | 8095 | 38395 | | Bitcoin Testnet | 19030 | 19130 | 18030 | 48330 | | Bitcoin Cash Testnet | 19031 | 19131 | 18031 | 48331 | | Zcash Testnet | 19032 | 19132 | 18032 | 48332 | diff --git a/tests/rpc/testdata/bitzeny.json b/tests/rpc/testdata/bitzeny.json new file mode 100644 index 00000000..34c5b87e --- /dev/null +++ b/tests/rpc/testdata/bitzeny.json @@ -0,0 +1,45 @@ +{ + "blockHeight": 1851162, + "blockHash": "0000000050a2ab1816b07e63ee9faf8cefbb44a65192e1c5a7360c41efd1d1ef", + "blockTime": 1583392607, + "blockTxs": [ + "e55b40c050117cf6cb2e1f35772c00bdc33a1fb8473bca0e3ff99b0e88c70397", + "f81c34b300961877328c3aaa7cd5e69068457868309fbf1e92544e3a6a915bcb" + ], + "txDetails": { + "f81c34b300961877328c3aaa7cd5e69068457868309fbf1e92544e3a6a915bcb": { + "hex": "0100000001aef422fb91cd91e556966fed4121ac44017a761d71385596536bb447ae05213e000000006a47304402202341ac4297925257dc72eb418a069c45e76f7070340e27501f6308cc7eff45f802204a347915adceff5f6fc9b8075d95d47887d46b344c7bbc8066d315931b189ad001210228c2520812b7f8c63e7a088c61b6348b22fa0c98812e736a1fd896bc828d3c65feffffff028041f13d000000001976a91478379ea136bb5783b675cd11e412bf0703995aeb88aca9983141000000001976a9144d869697281ad18370313122795e56dfdc3a331388ac193f1c00", + "txid": "f81c34b300961877328c3aaa7cd5e69068457868309fbf1e92544e3a6a915bcb", + "blocktime": 1583392607, + "time": 1583392607, + "locktime": 1851161, + "version": 1, + "vin": [ + { + "txid": "3e2105ae47b46b53965538711d767a0144ac2141ed6f9656e591cd91fb22f4ae", + "vout": 0, + "scriptSig": { + "hex": "47304402202341ac4297925257dc72eb418a069c45e76f7070340e27501f6308cc7eff45f802204a347915adceff5f6fc9b8075d95d47887d46b344c7bbc8066d315931b189ad001210228c2520812b7f8c63e7a088c61b6348b22fa0c98812e736a1fd896bc828d3c65" + }, + "sequence": 4294967294 + } + ], + "vout": [ + { + "value": 10.39221120, + "n": 0, + "scriptPubKey": { + "hex": "76a91478379ea136bb5783b675cd11e412bf0703995aeb88ac" + } + }, + { + "value": 10.93769385, + "n": 1, + "scriptPubKey": { + "hex": "76a9144d869697281ad18370313122795e56dfdc3a331388ac" + } + } + ] + } + } +} \ No newline at end of file diff --git a/tests/sync/testdata/bitzeny.json b/tests/sync/testdata/bitzeny.json new file mode 100644 index 00000000..ee83b8a3 --- /dev/null +++ b/tests/sync/testdata/bitzeny.json @@ -0,0 +1,90 @@ +{ + "connectBlocks": { + "syncRanges": [ + {"lower": 1851157, "upper": 1851162} + ], + "blocks": { + "1851162": { + "height": 1851162, + "hash": "0000000050a2ab1816b07e63ee9faf8cefbb44a65192e1c5a7360c41efd1d1ef", + "noTxs": 2, + "txDetails": [ + { + "hex": "0100000001aef422fb91cd91e556966fed4121ac44017a761d71385596536bb447ae05213e000000006a47304402202341ac4297925257dc72eb418a069c45e76f7070340e27501f6308cc7eff45f802204a347915adceff5f6fc9b8075d95d47887d46b344c7bbc8066d315931b189ad001210228c2520812b7f8c63e7a088c61b6348b22fa0c98812e736a1fd896bc828d3c65feffffff028041f13d000000001976a91478379ea136bb5783b675cd11e412bf0703995aeb88aca9983141000000001976a9144d869697281ad18370313122795e56dfdc3a331388ac193f1c00", + "txid": "f81c34b300961877328c3aaa7cd5e69068457868309fbf1e92544e3a6a915bcb", + "version": 1, + "vin": [ + { + "txid": "3e2105ae47b46b53965538711d767a0144ac2141ed6f9656e591cd91fb22f4ae", + "vout": 0, + "sequence": 4294967294, + "scriptSig": { + "hex": "47304402202341ac4297925257dc72eb418a069c45e76f7070340e27501f6308cc7eff45f802204a347915adceff5f6fc9b8075d95d47887d46b344c7bbc8066d315931b189ad001210228c2520812b7f8c63e7a088c61b6348b22fa0c98812e736a1fd896bc828d3c65" + } + } + ], + "vout": [ + { + "value": 10.39221120, + "n": 0, + "scriptPubKey": { + "hex": "76a91478379ea136bb5783b675cd11e412bf0703995aeb88ac" + } + }, + { + "value": 10.93769385, + "n": 1, + "scriptPubKey": { + "hex": "76a9144d869697281ad18370313122795e56dfdc3a331388ac" + } + } + ], + "time": 1583392607, + "blocktime": 1583392607 + } + ] + } + } + }, + "handleFork": { + "syncRanges": [ + {"lower": 1851157, "upper": 1851162} + ], + "fakeBlocks": { + "1851159": { + "height": 1851159, + "hash": "0000000954c26c65b18f72bd3e09d21033b7bb5e5083834912c12ebd27a487a1" + }, + "1851160": { + "height": 1851160, + "hash": "0000001246c307c2c82e4186f48db5e3a8a3ce7d10247b904ecef36ed857aaa5" + }, + "1851161": { + "height": 1851161, + "hash": "0000000c6a16db38d0c8ccf070b67933a95d7a89bea070df19d129403164c937" + }, + "1851162": { + "height": 1851162, + "hash": "0000000983707dadd92795f29427ea403bb08eb7f58e5a005ee4389c0a3bb4f5" + } + }, + "realBlocks": { + "1851159": { + "height": 1851159, + "hash": "000000044e0aafd95fc2a7fa9ae55907c8995efa210bc323001e1369e6c2c36c" + }, + "1851160": { + "height": 1851160, + "hash": "0000000de74eea08d48f9a3235036aee30d3acf0ab2c2c6a6a58d1d3331b75ac" + }, + "1851161": { + "height": 1851161, + "hash": "000000157556e42684a33a917e5c64217fa33162ccf30167e28577d47dbecc2d" + }, + "1851162": { + "height": 1851162, + "hash": "0000000050a2ab1816b07e63ee9faf8cefbb44a65192e1c5a7360c41efd1d1ef" + } + } + } +} diff --git a/tests/tests.json b/tests/tests.json index 095b2d59..da443d97 100644 --- a/tests/tests.json +++ b/tests/tests.json @@ -32,6 +32,11 @@ "EstimateSmartFee", "EstimateFee", "GetBestBlockHash", "GetBestBlockHeight", "GetBlockHeader"], "sync": ["ConnectBlocksParallel", "ConnectBlocks", "HandleFork"] }, + "bitzeny": { + "rpc": ["GetBlock", "GetBlockHash", "GetTransaction", "GetTransactionForMempool", "MempoolSync", + "EstimateSmartFee", "EstimateFee", "GetBestBlockHash", "GetBestBlockHeight", "GetBlockHeader"], + "sync": ["ConnectBlocksParallel", "ConnectBlocks", "HandleFork"] + }, "cpuchain": { "rpc": ["GetBlock", "GetBlockHash", "GetTransaction", "GetTransactionForMempool", "MempoolSync", "EstimateSmartFee", "EstimateFee"],