diff --git a/Gopkg.lock b/Gopkg.lock index d3306553..a4242fc2 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -37,6 +37,12 @@ packages = ["."] revision = "12e86f41eb040d3b85b5d8e3a3a4bed035517c52" +[[projects]] + name = "github.com/deckarep/golang-set" + packages = ["."] + revision = "1d4478f51bed434f1dadf96dcd9b43aabac66795" + version = "v1.7" + [[projects]] name = "github.com/ethereum/go-ethereum" packages = [".","common","common/hexutil","common/math","core/types","crypto","crypto/secp256k1","crypto/sha3","ethclient","ethdb","log","metrics","params","rlp","rpc","trie"] @@ -202,6 +208,6 @@ [solve-meta] analyzer-name = "dep" analyzer-version = 1 - inputs-digest = "97b5e11b3aa46e6b54a5c3fd7835c49f324f9821a1c641e5682f60ee6716d8c2" + inputs-digest = "afcce626624acc0db803a97ce0238798cf034dc999161f32b4158c8033542cb7" solver-name = "gps-cdcl" solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml index e0144613..d9c354a1 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -37,10 +37,6 @@ branch = "master" name = "github.com/golang/glog" -[[constraint]] - name = "github.com/gorilla/handlers" - version = "1.3.0" - [[constraint]] name = "github.com/gorilla/mux" version = "1.6.1" diff --git a/bchain/coins/bch/bcashrpc_test.go b/bchain/coins/bch/bcashrpc_test.go index 948c1f0f..195eabc1 100644 --- a/bchain/coins/bch/bcashrpc_test.go +++ b/bchain/coins/bch/bcashrpc_test.go @@ -6,65 +6,120 @@ import ( "blockbook/bchain" "blockbook/bchain/tests/rpc" "encoding/json" + "flag" + "os" "testing" ) -func getRPCClient(cfg json.RawMessage) (bchain.BlockChain, error) { - c, err := NewBCashRPC(cfg, nil) - if err != nil { - return nil, err +func getRPCClient(chain string) func(json.RawMessage) (bchain.BlockChain, error) { + return func(cfg json.RawMessage) (bchain.BlockChain, error) { + c, err := NewBCashRPC(cfg, nil) + if err != nil { + return nil, err + } + cli := c.(*BCashRPC) + cli.Parser, err = NewBCashParser(GetChainParams(chain), cli.ChainConfig) + if err != nil { + return nil, err + } + cli.Mempool = bchain.NewUTXOMempool(cli, cli.ChainConfig.MempoolWorkers, cli.ChainConfig.MempoolSubWorkers) + return cli, nil } - cli := c.(*BCashRPC) - cli.Parser, err = NewBCashParser(GetChainParams("test"), cli.ChainConfig) - if err != nil { - return nil, err - } - cli.Mempool = bchain.NewUTXOMempool(cli, cli.ChainConfig.MempoolWorkers, cli.ChainConfig.MempoolSubWorkers) - return cli, nil } -var rpcTest *rpc.Test +var tests struct { + mainnet *rpc.Test + testnet *rpc.Test +} -func init() { - t, err := rpc.NewTest("Bcash Testnet", getRPCClient) +func TestMain(m *testing.M) { + flag.Parse() + + t, err := rpc.NewTest("Bcash", getRPCClient("main")) if err != nil { panic(err) } - rpcTest = t + + tests.mainnet = t + + t, err = rpc.NewTest("Bcash Testnet", getRPCClient("test")) + if err != nil { + panic(err) + } + + tests.testnet = t + + os.Exit(m.Run()) } func TestBCashRPC_GetBlockHash(t *testing.T) { - rpcTest.TestGetBlockHash(t) + tests.mainnet.TestGetBlockHash(t) } func TestBCashRPC_GetBlock(t *testing.T) { - rpcTest.TestGetBlock(t) + tests.mainnet.TestGetBlock(t) } func TestBCashRPC_GetTransaction(t *testing.T) { - rpcTest.TestGetTransaction(t) + tests.mainnet.TestGetTransaction(t) } -func TestBCashRPC_TestGetTransactionForMempool(t *testing.T) { - rpcTest.TestGetTransactionForMempool(t) +func TestBCashRPC_GetTransactionForMempool(t *testing.T) { + tests.mainnet.TestGetTransactionForMempool(t) } -func TestBCashRPC_TestMempoolSync(t *testing.T) { - rpcTest.TestMempoolSync(t) +func TestBCashRPC_MempoolSync(t *testing.T) { + tests.mainnet.TestMempoolSync(t) } func TestBCashRPC_GetMempoolEntry(t *testing.T) { - rpcTest.TestGetMempoolEntry(t) + tests.mainnet.TestGetMempoolEntry(t) } func TestBCashRPC_SendRawTransaction(t *testing.T) { - rpcTest.TestSendRawTransaction(t) + tests.mainnet.TestSendRawTransaction(t) } func TestBCashRPC_EstimateSmartFee(t *testing.T) { - rpcTest.TestEstimateSmartFee(t) + tests.mainnet.TestEstimateSmartFee(t) } func TestBCashRPC_EstimateFee(t *testing.T) { - rpcTest.TestEstimateFee(t) + tests.mainnet.TestEstimateFee(t) +} + +func TestBCashTestnetRPC_GetBlockHash(t *testing.T) { + tests.testnet.TestGetBlockHash(t) +} + +func TestBCashTestnetRPC_GetBlock(t *testing.T) { + tests.testnet.TestGetBlock(t) +} + +func TestBCashTestnetRPC_GetTransaction(t *testing.T) { + tests.testnet.TestGetTransaction(t) +} + +func TestBCashTestnetRPC_GetTransactionForMempool(t *testing.T) { + tests.testnet.TestGetTransactionForMempool(t) +} + +func TestBCashTestnetRPC_MempoolSync(t *testing.T) { + tests.testnet.TestMempoolSync(t) +} + +func TestBCashTestnetRPC_GetMempoolEntry(t *testing.T) { + tests.testnet.TestGetMempoolEntry(t) +} + +func TestBCashTestnetRPC_SendRawTransaction(t *testing.T) { + tests.testnet.TestSendRawTransaction(t) +} + +func TestBCashTestnetRPC_EstimateSmartFee(t *testing.T) { + tests.testnet.TestEstimateSmartFee(t) +} + +func TestBCashTestnetRPC_EstimateFee(t *testing.T) { + tests.testnet.TestEstimateFee(t) } diff --git a/bchain/coins/btc/bitcoinrpc_test.go b/bchain/coins/btc/bitcoinrpc_test.go index 266e6a35..a127fa49 100644 --- a/bchain/coins/btc/bitcoinrpc_test.go +++ b/bchain/coins/btc/bitcoinrpc_test.go @@ -6,65 +6,119 @@ import ( "blockbook/bchain" "blockbook/bchain/tests/rpc" "encoding/json" + "flag" + "os" "testing" ) -func getRPCClient(cfg json.RawMessage) (bchain.BlockChain, error) { - c, err := NewBitcoinRPC(cfg, nil) - if err != nil { - return nil, err +func getRPCClient(chain string) func(json.RawMessage) (bchain.BlockChain, error) { + return func(cfg json.RawMessage) (bchain.BlockChain, error) { + c, err := NewBitcoinRPC(cfg, nil) + if err != nil { + return nil, err + } + cli := c.(*BitcoinRPC) + cli.Parser = NewBitcoinParser(GetChainParams(chain), cli.ChainConfig) + if err != nil { + return nil, err + } + cli.Mempool = bchain.NewUTXOMempool(cli, cli.ChainConfig.MempoolWorkers, cli.ChainConfig.MempoolSubWorkers) + return cli, nil } - cli := c.(*BitcoinRPC) - cli.Parser = NewBitcoinParser(GetChainParams("test"), cli.ChainConfig) - if err != nil { - return nil, err - } - cli.Mempool = bchain.NewUTXOMempool(cli, cli.ChainConfig.MempoolWorkers, cli.ChainConfig.MempoolSubWorkers) - return cli, nil } -var rpcTest *rpc.Test +var tests struct { + mainnet *rpc.Test + testnet *rpc.Test +} -func init() { - t, err := rpc.NewTest("Bitcoin Testnet", getRPCClient) +func TestMain(m *testing.M) { + flag.Parse() + t, err := rpc.NewTest("Bitcoin", getRPCClient("main")) if err != nil { panic(err) } - rpcTest = t + + tests.mainnet = t + + t, err = rpc.NewTest("Bitcoin Testnet", getRPCClient("test")) + if err != nil { + panic(err) + } + + tests.testnet = t + + os.Exit(m.Run()) } func TestBitcoinRPC_GetBlockHash(t *testing.T) { - rpcTest.TestGetBlockHash(t) + tests.mainnet.TestGetBlockHash(t) } func TestBitcoinRPC_GetBlock(t *testing.T) { - rpcTest.TestGetBlock(t) + tests.mainnet.TestGetBlock(t) } func TestBitcoinRPC_GetTransaction(t *testing.T) { - rpcTest.TestGetTransaction(t) + tests.mainnet.TestGetTransaction(t) } -func TestBitcoinRPC_TestGetTransactionForMempool(t *testing.T) { - rpcTest.TestGetTransactionForMempool(t) +func TestBitcoinRPC_GetTransactionForMempool(t *testing.T) { + tests.mainnet.TestGetTransactionForMempool(t) } -func TestBitcoinRPC_TestMempoolSync(t *testing.T) { - rpcTest.TestMempoolSync(t) +func TestBitcoinRPC_MempoolSync(t *testing.T) { + tests.mainnet.TestMempoolSync(t) } func TestBitcoinRPC_GetMempoolEntry(t *testing.T) { - rpcTest.TestGetMempoolEntry(t) + tests.mainnet.TestGetMempoolEntry(t) } func TestBitcoinRPC_SendRawTransaction(t *testing.T) { - rpcTest.TestSendRawTransaction(t) + tests.mainnet.TestSendRawTransaction(t) } func TestBitcoinRPC_EstimateSmartFee(t *testing.T) { - rpcTest.TestEstimateSmartFee(t) + tests.mainnet.TestEstimateSmartFee(t) } func TestBitcoinRPC_EstimateFee(t *testing.T) { - rpcTest.TestEstimateFee(t) + tests.mainnet.TestEstimateFee(t) +} + +func TestBitcoinTestnetRPC_GetBlockHash(t *testing.T) { + tests.testnet.TestGetBlockHash(t) +} + +func TestBitcoinTestnetRPC_GetBlock(t *testing.T) { + tests.testnet.TestGetBlock(t) +} + +func TestBitcoinTestnetRPC_GetTransaction(t *testing.T) { + tests.testnet.TestGetTransaction(t) +} + +func TestBitcoinTestnetRPC_GetTransactionForMempool(t *testing.T) { + tests.testnet.TestGetTransactionForMempool(t) +} + +func TestBitcoinTestnetRPC_MempoolSync(t *testing.T) { + tests.testnet.TestMempoolSync(t) +} + +func TestBitcoinTestnetRPC_GetMempoolEntry(t *testing.T) { + tests.testnet.TestGetMempoolEntry(t) +} + +func TestBitcoinTestnetRPC_SendRawTransaction(t *testing.T) { + tests.testnet.TestSendRawTransaction(t) +} + +func TestBitcoinTestnetRPC_EstimateSmartFee(t *testing.T) { + tests.testnet.TestEstimateSmartFee(t) +} + +func TestBitcoinTestnetRPC_EstimateFee(t *testing.T) { + tests.testnet.TestEstimateFee(t) } diff --git a/bchain/coins/dash/dashrpc_test.go b/bchain/coins/dash/dashrpc_test.go index ebfa2847..b406d21a 100644 --- a/bchain/coins/dash/dashrpc_test.go +++ b/bchain/coins/dash/dashrpc_test.go @@ -6,58 +6,108 @@ import ( "blockbook/bchain" "blockbook/bchain/tests/rpc" "encoding/json" + "flag" + "os" "testing" ) -func getRPCClient(cfg json.RawMessage) (bchain.BlockChain, error) { - c, err := NewDashRPC(cfg, nil) - if err != nil { - return nil, err +func getRPCClient(chain string) func(json.RawMessage) (bchain.BlockChain, error) { + return func(cfg json.RawMessage) (bchain.BlockChain, error) { + c, err := NewDashRPC(cfg, nil) + if err != nil { + return nil, err + } + cli := c.(*DashRPC) + cli.Parser = NewDashParser(GetChainParams(chain), cli.ChainConfig) + cli.Mempool = bchain.NewUTXOMempool(cli, cli.ChainConfig.MempoolWorkers, cli.ChainConfig.MempoolSubWorkers) + return cli, nil } - cli := c.(*DashRPC) - cli.Parser = NewDashParser(GetChainParams("test"), cli.ChainConfig) - cli.Mempool = bchain.NewUTXOMempool(cli, cli.ChainConfig.MempoolWorkers, cli.ChainConfig.MempoolSubWorkers) - return cli, nil } -var rpcTest *rpc.Test +var tests struct { + mainnet *rpc.Test + testnet *rpc.Test +} -func init() { - t, err := rpc.NewTest("Dash Testnet", getRPCClient) +func TestMain(m *testing.M) { + flag.Parse() + t, err := rpc.NewTest("Dash", getRPCClient("main")) if err != nil { panic(err) } - rpcTest = t + + tests.mainnet = t + + t, err = rpc.NewTest("Dash Testnet", getRPCClient("test")) + if err != nil { + panic(err) + } + + tests.testnet = t + + os.Exit(m.Run()) } func TestDashRPC_GetBlockHash(t *testing.T) { - rpcTest.TestGetBlockHash(t) + tests.mainnet.TestGetBlockHash(t) } func TestDashRPC_GetBlock(t *testing.T) { - rpcTest.TestGetBlock(t) + tests.mainnet.TestGetBlock(t) } func TestDashRPC_GetTransaction(t *testing.T) { - rpcTest.TestGetTransaction(t) + tests.mainnet.TestGetTransaction(t) } -func TestDashRPC_TestGetTransactionForMempool(t *testing.T) { - rpcTest.TestGetTransactionForMempool(t) +func TestDashRPC_GetTransactionForMempool(t *testing.T) { + tests.mainnet.TestGetTransactionForMempool(t) } -func TestDashRPC_TestMempoolSync(t *testing.T) { - rpcTest.TestMempoolSync(t) +func TestDashRPC_MempoolSync(t *testing.T) { + tests.mainnet.TestMempoolSync(t) } func TestDashRPC_SendRawTransaction(t *testing.T) { - rpcTest.TestSendRawTransaction(t) + tests.mainnet.TestSendRawTransaction(t) } func TestDashRPC_EstimateSmartFee(t *testing.T) { - rpcTest.TestEstimateSmartFee(t) + tests.mainnet.TestEstimateSmartFee(t) } func TestDashRPC_EstimateFee(t *testing.T) { - rpcTest.TestEstimateFee(t) + tests.mainnet.TestEstimateFee(t) +} + +func TestDashTestnetRPC_GetBlockHash(t *testing.T) { + tests.testnet.TestGetBlockHash(t) +} + +func TestDashTestnetRPC_GetBlock(t *testing.T) { + tests.testnet.TestGetBlock(t) +} + +func TestDashTestnetRPC_GetTransaction(t *testing.T) { + tests.testnet.TestGetTransaction(t) +} + +func TestDashTestnetRPC_GetTransactionForMempool(t *testing.T) { + tests.testnet.TestGetTransactionForMempool(t) +} + +func TestDashTestnetRPC_MempoolSync(t *testing.T) { + tests.testnet.TestMempoolSync(t) +} + +func TestDashTestnetRPC_SendRawTransaction(t *testing.T) { + tests.testnet.TestSendRawTransaction(t) +} + +func TestDashTestnetRPC_EstimateSmartFee(t *testing.T) { + tests.testnet.TestEstimateSmartFee(t) +} + +func TestDashTestnetRPC_EstimateFee(t *testing.T) { + tests.testnet.TestEstimateFee(t) } diff --git a/bchain/coins/eth/ethrpc_test.go b/bchain/coins/eth/ethrpc_test.go index f4794edc..db71706a 100644 --- a/bchain/coins/eth/ethrpc_test.go +++ b/bchain/coins/eth/ethrpc_test.go @@ -6,6 +6,8 @@ import ( "blockbook/bchain" "blockbook/bchain/tests/rpc" "encoding/json" + "flag" + "os" "reflect" "testing" @@ -22,12 +24,16 @@ func getRPCClient(cfg json.RawMessage) (bchain.BlockChain, error) { var rpcTest *rpc.Test -func init() { +func TestMain(m *testing.M) { + flag.Parse() t, err := rpc.NewTest("Ethereum Testnet", getRPCClient) if err != nil { panic(err) } + rpcTest = t + + os.Exit(m.Run()) } func TestEthRPC_GetBlockHash(t *testing.T) { diff --git a/bchain/coins/namecoin/namecoinrpc_test.go b/bchain/coins/namecoin/namecoinrpc_test.go new file mode 100644 index 00000000..59af97d6 --- /dev/null +++ b/bchain/coins/namecoin/namecoinrpc_test.go @@ -0,0 +1,78 @@ +// +build integration + +package namecoin + +import ( + "blockbook/bchain" + "blockbook/bchain/tests/rpc" + "encoding/json" + "flag" + "os" + "testing" +) + +func getRPCClient(cfg json.RawMessage) (bchain.BlockChain, error) { + c, err := NewNamecoinRPC(cfg, nil) + if err != nil { + return nil, err + } + cli := c.(*NamecoinRPC) + cli.Parser = NewNamecoinParser(GetChainParams("main"), cli.ChainConfig) + if err != nil { + return nil, err + } + cli.Mempool = bchain.NewUTXOMempool(cli, cli.ChainConfig.MempoolWorkers, cli.ChainConfig.MempoolSubWorkers) + return cli, nil +} + +var rpcTest *rpc.Test + +func TestMain(m *testing.M) { + flag.Parse() + t, err := rpc.NewTest("Namecoin", getRPCClient) + if err != nil { + panic(err) + } + + rpcTest = t + + os.Exit(m.Run()) +} + +func TestNamecoinRPC_GetBlockHash(t *testing.T) { + rpcTest.TestGetBlockHash(t) +} + +func TestNamecoinRPC_GetBlock(t *testing.T) { + rpcTest.TestGetBlock(t) +} + +func TestNamecoinRPC_GetTransaction(t *testing.T) { + rpcTest.TestGetTransaction(t) +} + +func TestNamecoinRPC_GetTransactionForMempool(t *testing.T) { + // extra opcodes (name_new, name_firstupdate, name_update) aren't supported, so some transactions + // in mempool can't be parsed correctly + t.Skipf("Skipped because of instability") +} + +func TestNamecoinRPC_MempoolSync(t *testing.T) { + rpcTest.TestMempoolSync(t) +} + +func TestNamecoinRPC_GetMempoolEntry(t *testing.T) { + rpcTest.TestGetMempoolEntry(t) +} + +func TestNamecoinRPC_SendRawTransaction(t *testing.T) { + rpcTest.TestSendRawTransaction(t) +} + +func TestNamecoinRPC_EstimateSmartFee(t *testing.T) { + rpcTest.TestEstimateSmartFee(t) +} + +func TestNamecoinRPC_EstimateFee(t *testing.T) { + rpcTest.TestEstimateFee(t) +} diff --git a/bchain/coins/vertcoin/vertcoinrpc_test.go b/bchain/coins/vertcoin/vertcoinrpc_test.go new file mode 100644 index 00000000..8aeadff9 --- /dev/null +++ b/bchain/coins/vertcoin/vertcoinrpc_test.go @@ -0,0 +1,76 @@ +// +build integration + +package vertcoin + +import ( + "blockbook/bchain" + "blockbook/bchain/tests/rpc" + "encoding/json" + "flag" + "os" + "testing" +) + +func getRPCClient(cfg json.RawMessage) (bchain.BlockChain, error) { + c, err := NewVertcoinRPC(cfg, nil) + if err != nil { + return nil, err + } + cli := c.(*VertcoinRPC) + cli.Parser = NewVertcoinParser(GetChainParams("main"), cli.ChainConfig) + if err != nil { + return nil, err + } + cli.Mempool = bchain.NewUTXOMempool(cli, cli.ChainConfig.MempoolWorkers, cli.ChainConfig.MempoolSubWorkers) + return cli, nil +} + +var rpcTest *rpc.Test + +func TestMain(m *testing.M) { + flag.Parse() + t, err := rpc.NewTest("Vertcoin", getRPCClient) + if err != nil { + panic(err) + } + + rpcTest = t + + os.Exit(m.Run()) +} + +func TestVertcoinRPC_GetBlockHash(t *testing.T) { + rpcTest.TestGetBlockHash(t) +} + +func TestVertcoinRPC_GetBlock(t *testing.T) { + rpcTest.TestGetBlock(t) +} + +func TestVertcoinRPC_GetTransaction(t *testing.T) { + rpcTest.TestGetTransaction(t) +} + +func TestVertcoinRPC_GetTransactionForMempool(t *testing.T) { + rpcTest.TestGetTransactionForMempool(t) +} + +func TestVertcoinRPC_MempoolSync(t *testing.T) { + rpcTest.TestMempoolSync(t) +} + +func TestVertcoinRPC_GetMempoolEntry(t *testing.T) { + rpcTest.TestGetMempoolEntry(t) +} + +func TestVertcoinRPC_SendRawTransaction(t *testing.T) { + rpcTest.TestSendRawTransaction(t) +} + +func TestVertcoinRPC_EstimateSmartFee(t *testing.T) { + rpcTest.TestEstimateSmartFee(t) +} + +func TestVertcoinRPC_EstimateFee(t *testing.T) { + rpcTest.TestEstimateFee(t) +} diff --git a/bchain/coins/zec/zcashrpc_test.go b/bchain/coins/zec/zcashrpc_test.go index 4c6f7e1f..e331625c 100644 --- a/bchain/coins/zec/zcashrpc_test.go +++ b/bchain/coins/zec/zcashrpc_test.go @@ -6,6 +6,8 @@ import ( "blockbook/bchain" "blockbook/bchain/tests/rpc" "encoding/json" + "flag" + "os" "testing" ) @@ -20,44 +22,91 @@ func getRPCClient(cfg json.RawMessage) (bchain.BlockChain, error) { return cli, nil } -var rpcTest *rpc.Test +var tests struct { + mainnet *rpc.Test + testnet *rpc.Test +} -func init() { - t, err := rpc.NewTest("Zcash Testnet", getRPCClient) +func TestMain(m *testing.M) { + flag.Parse() + + t, err := rpc.NewTest("Zcash", getRPCClient) if err != nil { panic(err) } - rpcTest = t + + tests.mainnet = t + + t, err = rpc.NewTest("Zcash Testnet", getRPCClient) + if err != nil { + panic(err) + } + + tests.testnet = t + + os.Exit(m.Run()) } func TestZCashRPC_GetBlockHash(t *testing.T) { - rpcTest.TestGetBlockHash(t) + tests.mainnet.TestGetBlockHash(t) } func TestZCashRPC_GetBlock(t *testing.T) { - rpcTest.TestGetBlock(t) + tests.mainnet.TestGetBlock(t) } func TestZCashRPC_GetTransaction(t *testing.T) { - rpcTest.TestGetTransaction(t) + tests.mainnet.TestGetTransaction(t) } -func TestZCashRPC_TestGetTransactionForMempool(t *testing.T) { - rpcTest.TestGetTransactionForMempool(t) +func TestZCashRPC_GetTransactionForMempool(t *testing.T) { + tests.mainnet.TestGetTransactionForMempool(t) } -func TestZCashRPC_TestMempoolSync(t *testing.T) { - rpcTest.TestMempoolSync(t) +func TestZCashRPC_MempoolSync(t *testing.T) { + tests.mainnet.TestMempoolSync(t) } func TestZCashRPC_SendRawTransaction(t *testing.T) { - rpcTest.TestSendRawTransaction(t) + tests.mainnet.TestSendRawTransaction(t) } func TestZCashRPC_EstimateSmartFee(t *testing.T) { - rpcTest.TestEstimateSmartFee(t) + tests.mainnet.TestEstimateSmartFee(t) } func TestZCashRPC_EstimateFee(t *testing.T) { - rpcTest.TestEstimateFee(t) + tests.mainnet.TestEstimateFee(t) +} + +func TestZCashTestnetRPC_GetBlockHash(t *testing.T) { + tests.testnet.TestGetBlockHash(t) +} + +func TestZCashTestnetRPC_GetBlock(t *testing.T) { + tests.testnet.TestGetBlock(t) +} + +func TestZCashTestnetRPC_GetTransaction(t *testing.T) { + tests.testnet.TestGetTransaction(t) +} + +func TestZCashTestnetRPC_GetTransactionForMempool(t *testing.T) { + tests.testnet.TestGetTransactionForMempool(t) +} + +func TestZCashTestnetRPC_MempoolSync(t *testing.T) { + tests.testnet.TestMempoolSync(t) +} + +func TestZCashTestnetRPC_SendRawTransaction(t *testing.T) { + tests.testnet.TestSendRawTransaction(t) +} + +func TestZCashTestnetRPC_EstimateSmartFee(t *testing.T) { + tests.testnet.TestEstimateSmartFee(t) +} + +func TestZCashTestnetRPC_EstimateFee(t *testing.T) { + tests.testnet.TestEstimateFee(t) } diff --git a/bchain/tests/rpc/config.json b/bchain/tests/rpc/config.json index 086a0105..e4019e07 100644 --- a/bchain/tests/rpc/config.json +++ b/bchain/tests/rpc/config.json @@ -1,4 +1,39 @@ { + "Bcash": { + "url": "http://localhost:8031", + "user": "rpc", + "pass": "rpc" + }, + "Bitcoin": { + "url": "http://localhost:8030", + "user": "rpc", + "pass": "rpc" + }, + "Dash": { + "url": "http://localhost:8033", + "user": "rpc", + "pass": "rpc" + }, + "Ethereum": { + "url": "ws://localhost:8036", + "user": null, + "pass": null + }, + "Zcash": { + "url": "http://localhost:8032", + "user": "rpc", + "pass": "rpc" + }, + "Vertcoin": { + "url": "http://localhost:8040", + "user": "rpc", + "pass": "rpc" + }, + "Namecoin": { + "url": "http://localhost:8039", + "user": "rpc", + "pass": "rpc" + }, "Bcash Testnet": { "url": "http://localhost:18031", "user": "rpc", diff --git a/bchain/tests/rpc/rpc.go b/bchain/tests/rpc/rpc.go index 9cee0ac8..260b4754 100644 --- a/bchain/tests/rpc/rpc.go +++ b/bchain/tests/rpc/rpc.go @@ -6,9 +6,11 @@ import ( "blockbook/bchain" "encoding/json" "math/rand" + "net" "reflect" "testing" - "time" + + "github.com/deckarep/golang-set" ) type TestConfig struct { @@ -20,44 +22,70 @@ type TestConfig struct { type TestData struct { BlockHeight uint32 `json:"blockHeight"` BlockHash string `json:"blockHash"` - BlockHex string `json:"blockHex"` BlockTxs []string `json:"blockTxs"` TxDetails map[string]*bchain.Tx `json:"txDetails"` } type Test struct { - Client bchain.BlockChain - TestData *TestData + Client bchain.BlockChain + TestData *TestData + connected bool } type TestChainFactoryFunc func(json.RawMessage) (bchain.BlockChain, error) func NewTest(coin string, factory TestChainFactoryFunc) (*Test, error) { - cfg, err := LoadRPCConfig(coin) - if err != nil { - return nil, err - } - cli, err := factory(cfg) - if err != nil { - return nil, err - } - td, err := LoadTestData(coin) + var ( + connected = true + cli bchain.BlockChain + cfg json.RawMessage + td *TestData + err error + ) + + cfg, err = LoadRPCConfig(coin) if err != nil { return nil, err } - if td.TxDetails != nil { - parser := cli.GetChainParser() + cli, err = factory(cfg) + if err != nil { + if isNetError(err) { + connected = false + } else { + return nil, err + } + } else { + td, err = LoadTestData(coin) + if err != nil { + return nil, err + } - for _, tx := range td.TxDetails { - err := setTxAddresses(parser, tx) - if err != nil { - return nil, err + if td.TxDetails != nil { + parser := cli.GetChainParser() + + for _, tx := range td.TxDetails { + err := setTxAddresses(parser, tx) + if err != nil { + return nil, err + } } } + + _, err = cli.GetBlockChainInfo() + if err != nil && isNetError(err) { + connected = false + } } - return &Test{Client: cli, TestData: td}, nil + return &Test{Client: cli, TestData: td, connected: connected}, nil +} + +func isNetError(err error) bool { + if _, ok := err.(net.Error); ok { + return true + } + return false } func setTxAddresses(parser bchain.BlockChainParser, tx *bchain.Tx) error { @@ -75,7 +103,16 @@ func setTxAddresses(parser bchain.BlockChainParser, tx *bchain.Tx) error { } return err } + +func (rt *Test) skipUnconnected(t *testing.T) { + if !rt.connected { + t.Skip("Skipping test, not connected to backend service") + } +} + func (rt *Test) TestGetBlockHash(t *testing.T) { + rt.skipUnconnected(t) + hash, err := rt.Client.GetBlockHash(rt.TestData.BlockHeight) if err != nil { t.Error(err) @@ -88,6 +125,8 @@ func (rt *Test) TestGetBlockHash(t *testing.T) { } func (rt *Test) TestGetBlock(t *testing.T) { + rt.skipUnconnected(t) + blk, err := rt.Client.GetBlock(rt.TestData.BlockHash, 0) if err != nil { t.Error(err) @@ -107,6 +146,8 @@ func (rt *Test) TestGetBlock(t *testing.T) { } func (rt *Test) TestGetTransaction(t *testing.T) { + rt.skipUnconnected(t) + for txid, want := range rt.TestData.TxDetails { got, err := rt.Client.GetTransaction(txid) if err != nil { @@ -127,63 +168,44 @@ func (rt *Test) TestGetTransaction(t *testing.T) { } } -func (rt *Test) getMempool(t *testing.T) []string { - var ( - txs []string - err error - ) - // attempts to get transactions for 2 min - for i := 0; i < 8; i++ { - txs, err = rt.Client.GetMempool() +func (rt *Test) TestGetTransactionForMempool(t *testing.T) { + rt.skipUnconnected(t) + + for txid, want := range rt.TestData.TxDetails { + // reset fields that are not parsed by BlockChainParser + want.Confirmations, want.Blocktime, want.Time = 0, 0, 0 + + got, err := rt.Client.GetTransactionForMempool(txid) if err != nil { t.Fatal(err) } - if len(txs) == 0 { - time.Sleep(15 * time.Second) - continue + // transactions parsed from JSON may contain additional data + got.Confirmations, got.Blocktime, got.Time = 0, 0, 0 + if !reflect.DeepEqual(got, want) { + t.Errorf("GetTransactionForMempool() got %v, want %v", got, want) } + } +} - // done - break +func (rt *Test) getMempool(t *testing.T) []string { + txs, err := rt.Client.GetMempool() + if err != nil { + t.Fatal(err) } if len(txs) == 0 { - t.Skipf("Skipping test, all attempts to get mempool failed") + t.Skip("Skipping test, mempool is empty") } return txs } -func (rt *Test) getMempoolTransaction(t *testing.T, txid string) *bchain.Tx { - tx, err := rt.Client.GetTransactionForMempool(txid) - if err != nil { - t.Fatal(err) - } - if tx.Confirmations > 0 { - t.Skip("Skipping test, transaction moved away from mepool") - } - - return tx -} - -func (rt *Test) TestGetTransactionForMempool(t *testing.T) { - txs := rt.getMempool(t) - txid := txs[rand.Intn(len(txs))] - got := rt.getMempoolTransaction(t, txid) - - want, err := rt.Client.GetTransaction(txid) - if err != nil { - t.Fatal(err) - } - - if !reflect.DeepEqual(got, want) { - t.Errorf("GetTransactionForMempool() got %v, want %v", got, want) - } -} - func (rt *Test) getMempoolAddresses(t *testing.T, txs []string) map[string][]string { txid2addrs := map[string][]string{} for i := 0; i < len(txs); i++ { - tx := rt.getMempoolTransaction(t, txs[i]) + tx, err := rt.Client.GetTransactionForMempool(txs[i]) + if err != nil { + t.Fatal(err) + } addrs := []string{} for _, vin := range tx.Vin { for _, a := range vin.Addresses { @@ -203,34 +225,38 @@ func (rt *Test) getMempoolAddresses(t *testing.T, txs []string) map[string][]str } func (rt *Test) TestMempoolSync(t *testing.T) { + rt.skipUnconnected(t) + for i := 0; i < 3; i++ { txs := rt.getMempool(t) - txid2addrs := rt.getMempoolAddresses(t, txs) - if len(txid2addrs) == 0 { - t.Fatal("No transaction in mempool has any address") - } n, err := rt.Client.ResyncMempool(nil) if err != nil { t.Fatal(err) } - - if tmp := rt.getMempool(t); len(txs) != len(tmp) { - // mempool reset + if n == 0 { + // no transactions to test continue } - if len(txs) != n { - t.Fatalf("ResyncMempool() returned different number of transactions than backend call") + txs = intersect(txs, rt.getMempool(t)) + if len(txs) == 0 { + // no transactions to test + continue + } + + txid2addrs := rt.getMempoolAddresses(t, txs) + if len(txid2addrs) == 0 { + t.Skip("Skipping test, no addresses in mempool") } for txid, addrs := range txid2addrs { for _, a := range addrs { - txs, err := rt.Client.GetMempoolTransactions(a) + got, err := rt.Client.GetMempoolTransactions(a) if err != nil { t.Fatal(err) } - if !containsString(txs, txid) { + if !containsString(got, txid) { t.Errorf("ResyncMempool() - for address %s, transaction %s wasn't found in mempool", a, txid) return } @@ -243,6 +269,23 @@ func (rt *Test) TestMempoolSync(t *testing.T) { t.Skip("Skipping test, all attempts to sync mempool failed due to network state changes") } +func intersect(a, b []string) []string { + setA := mapset.NewSet() + for _, v := range a { + setA.Add(v) + } + setB := mapset.NewSet() + for _, v := range b { + setB.Add(v) + } + inter := setA.Intersect(setB) + res := make([]string, 0, inter.Cardinality()) + for v := range inter.Iter() { + res = append(res, v.(string)) + } + return res +} + func containsString(slice []string, s string) bool { for i := 0; i < len(slice); i++ { if slice[i] == s { @@ -253,6 +296,8 @@ func containsString(slice []string, s string) bool { } func (rt *Test) TestGetMempoolEntry(t *testing.T) { + rt.skipUnconnected(t) + for i := 0; i < 3; i++ { txs := rt.getMempool(t) h, err := rt.Client.GetBestBlockHeight() @@ -260,16 +305,26 @@ func (rt *Test) TestGetMempoolEntry(t *testing.T) { t.Fatal(err) } - tx := rt.getMempoolTransaction(t, txs[rand.Intn(len(txs))]) - e, err := rt.Client.GetMempoolEntry(tx.Txid) + txid := txs[rand.Intn(len(txs))] + tx, err := rt.Client.GetTransactionForMempool(txid) if err != nil { - if err, ok := err.(*bchain.RPCError); ok && err.Code == -5 { - // mempool reset - continue - } + t.Fatal(err) + } + if tx.Confirmations > 0 { + // tx confirmed + continue } - if e.Height-h > 1 { + e, err := rt.Client.GetMempoolEntry(txid) + if err != nil { + if err, ok := err.(*bchain.RPCError); ok && err.Code == -5 { + // tx confirmed + continue + } + t.Fatal(err) + } + + if d := int(e.Height) - int(h); d < -1 || d > 1 { t.Errorf("GetMempoolEntry() got height %d, want %d", e.Height, h) } if e.Size <= 0 { @@ -286,6 +341,8 @@ func (rt *Test) TestGetMempoolEntry(t *testing.T) { } func (rt *Test) TestSendRawTransaction(t *testing.T) { + rt.skipUnconnected(t) + for txid, tx := range rt.TestData.TxDetails { _, err := rt.Client.SendRawTransaction(tx.Hex) if err != nil { @@ -298,6 +355,8 @@ func (rt *Test) TestSendRawTransaction(t *testing.T) { } func (rt *Test) TestEstimateSmartFee(t *testing.T) { + rt.skipUnconnected(t) + for _, blocks := range []int{1, 2, 3, 5, 10} { fee, err := rt.Client.EstimateSmartFee(blocks, true) if err != nil { @@ -310,6 +369,8 @@ func (rt *Test) TestEstimateSmartFee(t *testing.T) { } func (rt *Test) TestEstimateFee(t *testing.T) { + rt.skipUnconnected(t) + for _, blocks := range []int{1, 2, 3, 5, 10} { fee, err := rt.Client.EstimateFee(blocks) if err != nil { diff --git a/bchain/tests/rpc/testdata/Bcash.json b/bchain/tests/rpc/testdata/Bcash.json new file mode 100644 index 00000000..3d6f3b8f --- /dev/null +++ b/bchain/tests/rpc/testdata/Bcash.json @@ -0,0 +1,75 @@ +{ + "blockHeight": 179921, + "blockHash": "00000000000004e221e0d2adf41b5018cf75395cc83ff9ff70aab0569d21f9dc", + "blockTxs": [ + "46655a2258c204e5948245c248e1524222c1f22a9ca7c02de686c6b83f55f55e", + "d59084c6ab21033b29df358e1b23ecd1617d48ffbbb63ba567c769f9d48a2842", + "16296fd663e1bd0a9566534678cc64d6250222a3f03b8a6dbdc0b011003b1f2a", + "e6bcc688c5ba13f2ab9d6fdc39fe6dcdc94dc876d51dfbb1108f5252c515b26c", + "aaff4792985d8825f7365dea1f026aa4ec57d93af47da67b5c6839efe6c098d2", + "61f52169796a2490cf76cc2d68f6ca8d48971ead87b8815307ef53c608cca318", + "995c1ed442f0777adb652b36d1c5038c85663f3e3b6d0e26c819b21d710fadda", + "2eceaa18d1d1529cbbd385df69dbfd684977de4c545e905974afc35afe1fd358", + "c6f3a4a4bed847de0fee0118b43d3854e2b65f20d2319e084fbf448d4bd85c75", + "933cba6c287bdfaa0c7f4ec5f8f35ea51b59df1d539d0a32a28dcc99dce5b721", + "2373109ea6025b0b237aea1193c097cd1197e59e465382105f4d88a8d6ac0152", + "55117cf6c5f384f87cef2b789f36ff6d7b4f7ccbacf84834e1e09227fdce5ac9", + "c2348e1df31f12a61c8fc94542a43dc8feba3e215d01b5dd12251b68f918ceb2", + "01ab8e4d2324c3e466ee4c29863b34967791217aea13c0a12499a4362cd1af18", + "480603369259ea683b53369e9b8faf71f3f0b7de52e3bc6b67702f88a3a8bbf1", + "31c673e559d4b41c617fc197f0d60b6183a30e21d356a5a18ebc78086a32d69c", + "3ef0af7cc977e936eb43caeb1fb029660f3798fffc416695f9af4d7d9cbf9d1a", + "38ed7b5659ead06eeed927f8519e758b55caf3bedcd830f15f6d07166d624f0f", + "5f3d9ea5da6ee49d948d565e64a4d3c49f435b77f8ff10fe74e3536dff0079ea", + "15659d35fafb656804c1e92ff6593339b3103b02c55d8f9b2e6df08cbf150877", + "055254b83fb49387de92905b44da7c680758dd0da8ed5bcd8ee2297175089984", + "5530c68b861f6c202b3a3627b0639f199d92fcc0f6bc8b203ccc14a3e1a1aacd", + "971d2d9537dbc4a76c4026e5591b02b4f297208cbb38de4444da0dffc68273d4", + "5980150c623b9b231507ae0988d53a43d3bae00edbad2590cc27ebec05c6d54e", + "dc2a33f6697f72d7f88b20e381a131be25b244d144bdf578c09b902fc892e6b4", + "2858d0461ba9790c0e4d67e1b235cb9dcf0a06ac470db967f00d8783a141756b", + "2e5d7c5e86b0785d36bed7cae59debdd106372b10cc69243d8deb1cf1b902295", + "43cc4cc98fa121b4d0d9d82233322dd4d3b848c59c891438370b42b170ccea1e", + "3a71dea98514852654b4b6577178afeb836f995f07f2e0a82b6d775b31ff5549", + "198cedc3489dc531fced23477aec5eb5ca230213269a53fea4450e7a4574e773", + "4bd239288219fec9f8fdb0904e757eb4e338c8f04a4cf5302526a4f2a40aab40", + "4bfd6a3da24adf1f0569a89879110feefff35d8a01c8d3f6fddb58d44c740163", + "8e507a4edbeae5fe845b22d42b740186ff40d9152dc1483a8e9d13a7206830f9", + "75c0a8f6bdaf92ae0618e99e934f174a1b9984346ebd10b690767f1911df58fb" + ], + "txDetails": { + "61f52169796a2490cf76cc2d68f6ca8d48971ead87b8815307ef53c608cca318": { + "hex": "01000000013a5447f0e0aa71944dac8c5c9f104491a6a1454635821530cfdf11e41cf68156090000008a47304402206d997d39b79d31acfbb9add1af599cc93cb65264bb0324d56a50ffb443b98fca02203577a3fac4563d163c6a3ebb510ef16e873067b93fe3339eaa55dff60e20bffc014104b55697fa74b02962316e19eeb460eeca08be61e64bbe36c43a2c3429fd9dbd277dff78c8ea85b937d76c5f897f8ac0082fbd2d2b469f2dad8bfe480bae050fc9ffffffff02d69ce702000000001976a914b8605be5c0157121a7e5d787e2b2a1addd7a0ead88ac80841e00000000001976a91414d07495bc247fff4db76d3ed6b27b769e0006af88ac00000000", + "txid": "61f52169796a2490cf76cc2d68f6ca8d48971ead87b8815307ef53c608cca318", + "blocktime":1336884140, + "time":1336884140, + "locktime": 0, + "vin": [ + { + "txid": "5681f61ce411dfcf301582354645a1a69144109f5c8cac4d9471aae0f047543a", + "vout": 9, + "sequence": 4294967295, + "scriptSig": { + "hex": "47304402206d997d39b79d31acfbb9add1af599cc93cb65264bb0324d56a50ffb443b98fca02203577a3fac4563d163c6a3ebb510ef16e873067b93fe3339eaa55dff60e20bffc014104b55697fa74b02962316e19eeb460eeca08be61e64bbe36c43a2c3429fd9dbd277dff78c8ea85b937d76c5f897f8ac0082fbd2d2b469f2dad8bfe480bae050fc9" + } + } + ], + "vout": [ + { + "value": 0.48733398, + "n": 0, + "scriptPubKey": { + "hex": "76a914b8605be5c0157121a7e5d787e2b2a1addd7a0ead88ac" + } + }, + { + "value": 0.02000000, + "n": 1, + "scriptPubKey": { + "hex": "76a91414d07495bc247fff4db76d3ed6b27b769e0006af88ac" + } + } + ] + } + } +} diff --git a/bchain/tests/rpc/testdata/Bitcoin.json b/bchain/tests/rpc/testdata/Bitcoin.json new file mode 100644 index 00000000..0f7a09e4 --- /dev/null +++ b/bchain/tests/rpc/testdata/Bitcoin.json @@ -0,0 +1,192 @@ +{ + "blockHeight": 529150, + "blockHash": "00000000000000000035835503f43c878ebb643f3b40bdfd0dfda760da74e73c", + "blockTxs": [ + "8dd1379174e262d12a32d217e87a7caf09fa1b9e48a6fe010cac219f18c6de58", + "5fce44793b328ca5f142caadbf29efc78a0059d7a6379dff81fc6447b519a7c3", + "d5daab5d57ef089b0464932443bb52a818860e93c6a23d9a66e0749e0cc146da", + "96bf6e66ed65e6003b1c751a51ad6a4fa17465c73b64211989ebd50413a9cdc9", + "a81addeae3cddf2cb69a70f4dd85e2829bacc474b98a97ece6a7872cd15c37fe", + "dd6169e9227bc00e2f2bddf4f1eef6126998d984ce13083d7a11c6972ec6d25d", + "ca211af71c54c3d90b83851c1d35a73669040b82742dd7f95e39953b032f7d39", + "0d1463f05662ef6fa73f37c030908b8d890b8dabe217c25ebaf07057ecafafca", + "2276c68760b3ff3d32cf4ede7e4eb4be95b01d04629145a16bc57830b33fbc01", + "3abc8d3485a7505087997d63a72bb86d3cfce1b6b0057da722e2ae24715d8be5", + "88db71956b653875a06a84bbe6ef166df3b50c94a908f82d457192835be47c07", + "973e394c11a4339b25803eff85e9299688489c7e71b9110e77a6c469f996f9b4", + "7afbc04c39707ca334a6db6b94ec2421798770d6593b4ce1f19f64f6a6ae77b2", + "2a047219a5858c5a0068822b81775789ee07cdf0cdc91a2775dd2d520f390aa2", + "2ea3eebcdb11b46f0e5b42b7718eb1fb709b625bec98bee5e3bb7de32d456360", + "d37ee9bebeedb5aac15ece6e5d497371a43b4e93a060a92006530eb77d6fbd8a", + "a029561cbffc0b79bdc23fa987e463b16342aef976562ce13c213fa556d860ec", + "8f0e21edeff8b6654338c67b4e6980d82634c0d10509923afcab7a831a46683c", + "6884c257e43d4c7a81739acf852952b45d5bfb5fc07816fca326b94b174733c3", + "0206990ff4387238953164731fc7b3d216432e58db21a180bfd3eeeb8bf3e36a", + "f05d76253daaa0584feeac9b1ff7e57e8962dfa0731a8875a52871b201ce3bc5", + "65149c5de02e58416b7f923c0db4f1b3a945afbd8bd815beefc052e14bd7ac7d", + "e732c8fb6a2da39b22a39207d84ac0bd7450ced28617a47cc6b5b1166b9a74ec", + "24f4a06a88f234b63935ef74a7e42223ec8ab22689d497b2a29aee526dbdbb3e", + "6066e3885dd13f8ffdcb0d1a849a45bb79e0a2d0c140f7a45e957f9e9c1d7d39", + "43b3fa3c6e857df0a52ddc3d2e7fdb0c6593b1cda65251b5a4eef06bced31883", + "86c5b32ee229a59339caca990a364490fb9e2c7e5493810982849cb1d8e13f1a", + "95c9ea5d7c79cba2fd3ae868f1a73fe242ca3917ceef7027e9251b4d666fc43d", + "655296c13411a8973e97cab768f560f0dd297994c0189e9ca286adf4ec04393e", + "2cf86550a3a2497009b296e451cb94e58b713f3c2859e273fe2e4e160784672d", + "e89effee8a2787007b49d2fcdc880c66b2c1dc76bbf258e25f4dc07e8b362a8f", + "191f2d7ef3f7c2693a9930f4fcfa80769139fb7e10289dde71caa9102a329c39", + "6d5cf483c0013281a267bfa1d69fbe0a372c93b51eafc6c3b1ed2bb880b420e5", + "932684b0ce065488c8da5bc92b3a0c082971474ca48957c6c5c59bd20c37f285", + "33666f78256725d68a15b8e52c9c84ab6dbd7f74da474eb92e0909b3ff0f1c73", + "6e1df5ec9851f403b994d6a53e5aa8912838c9b775d250cdf31fcda0c2f1f4a4", + "ce87eccf8a294e2e0110d56a6ec1e5a4f854aea74a5bf7e7b00f9dd32ecb9341", + "820ed342a2e62613173c365b6ef9b35e4956d46a9f310fe4c4228488bf981a1e", + "4bd73f5b3e2f833e2922a62816d7fac391e7ecc3f628c7f15964efb64c4868fc", + "c3f2fab2af1efe1d8725497567cd6c791372ce3c71a2358e0f2ca175bdeaf9ca", + "aa4498ad03c15068515b21df561560fbbfc56d1bc05e8f396d2d22e023cfd19f", + "956e313eeb2a3364b6439d23338ea2e48a98ab04b9c82e2776d844c6247b4b77", + "22787283751d501687c42396110a59a390b45cc05ccf57493e523e2d66bfff31", + "a5a1c30d7b2e01e0b26179c74da3ecc1b68265583184fd548f5059d312ae3414", + "62ecf5ec79801ed7e4012ca8037d8deedc95e5c30ca7ec112a90d4ec5506eb6b", + "1898e3f94a7d68c73e828a0c87a74ff6f172f2b24240858229e63d603616fb21", + "cee2b19dc3021ecfb8a1f68060757d828088387708571c6a224e89a1ed9c14e6", + "930d785b0fa219930886cd5e93bab9f1f2111c67a5c089ee329745b2678c841d", + "7ad9179b7d990637f905ae3eb74b65792a3a7440aa7f59ba5274e211b26f649b", + "3e1ee4ddd2a990fc3195117005b4c53c9367316e85813ee437c43e927af08155", + "76cd3f44f4186757b0f2b83b66dfa02a85012f93a25d2ad670f30b97382adbb7", + "2e48b382fb84ac83f34e8c37baf89e6a87836b6eaf2a9180dcfd03d2816b4aee", + "dea813a8a0f702ba2800dd7046b138e81568edb089d26d93ee7a979225690e91", + "512c4c97ad1763bae3c0998d154e0e32897da633bc1558963d75dc57de164c8c", + "39d34eaec9b399df80b3d05b4b211f1b7b220578d13c9666a63f202afa8857f3", + "a79823ca003b64d78ccf28fad693eebba7e94c3089340c202199a459bc50dcbb", + "faef230df22406f367ba2e838b16eca0b581249a4476acc1a978613816dbec02", + "d99db7838ccb76c0ecfaa57b2c690cec56a711a5d880fe4e54853256bf213079", + "115122280ce9b781014584968e4b3e851e37141d81ebd403179c48c908672e92", + "7e08d9ec508fbaa69163e5aff05baf0e57af7503e11ac0dfe5dfeaf7b5f223c5", + "55c019b5aa708fe6c35e188db3f9561ff552ddb7edd142e3b4ca3743ee5ac6da", + "dff909d9469761d365083d1ba2e8702879d3455b03f09d98bbf3eee43ed155f6", + "81ce5eef1fcf57787da3c9deb75e715ba4039ea3c4a48cf5ed5206b889c3bc27", + "4d5d6fb00364fc40880f2912a28f1a6db506061dc85820d19af84ec31b5e5e60", + "4e9d2f8ff1b2e603d31449373d3b8a312661d6405e4be0aa2c679fecd486df7f", + "f7eb6eb8a3b5699956581c3e68b08f05da818e7bb1e2c28276cd638cacda7994", + "8b485e079126145df5704a813662e08f748fad098ea8d9b6b896879625724392", + "f7f05d889261ecc26968dbe03051e113584df5ca0c4bcff9e27664413c2e73d6", + "b4c531ea13369004393b5fc6835f5ac74bdc2f23adc5ad8e44a34256867496e2", + "3f63d00841e688e7006c7dff76c04a8caf183db36e00fb130b2a9bf64fad4cc3", + "edec5964af29256872caff91a8b74308346a10eaa1d17e5eeba4f5f0a4da8109", + "0d5db84f971ebdacae606c5f7c55a1d309ce6b45c5c1cab4097007047af4639b", + "2e438cad664dd495a7aaec45622880e3255f0822583b3ab5f7921800f49f962f", + "bb1c7b6b4c921283ac7f3683226d913824050bbb2150d58dae47c0dc541541a8", + "65d7aeaff3c481baca79cb2f3ca98026214258ca35bc78d4fa19aac8b01403ba", + "2ca7b1392be38314e4faffd4dd586327f27320fc7eeaaa8389f29a56a6e2d6ed", + "63da0eb29ad6c2523348f3bf97f78bd76124cd668a91b499553ac30aad7667d1", + "3f53be6d1ea2147f0c125da925b0bf95eadc74091e99fd9b79b562c507699446", + "023359558fa22bfa518f82e6a261079cce8b59b1cbe286d11ec741dae72a8d30", + "44d69736e6bef4885b6a2442ea4644da3c56586bc6cbabc984a23ce4a266cf54", + "e735844e2f88551f8da8a69171a05fda47fbdaa4ecd3d29b98eb167789f7a3ac", + "60428a78761e84826168626da18e7407780bd1188c13e6d4f12aaa67b632e0bb", + "ada31e8d2c0670ed091a0f75008ea3f0c37fc000f704c4b60575a69a0fda96c1", + "bc31227b15cf5ddcd5035c220dc9a37c39213dbaa97e536eb36339251750e202", + "90d51a46469bd8185245760ed25425dca259ffb1bda812c06bfabbf99dd54bf7", + "c46129d75b7ec2d85d166f1347a4c47c461d3dcd823a1f9b6e25ef41bd04d6a2", + "1ffe0fabb57af65df1dd8cf433298118deb9b10f7b91036e4accb94275d66801", + "6a7250ede081a5df65c263bef36954027cf4956e920f4dc8a143a9dc735f7470", + "f6a768252ef749a1ebc5a7240eae4367d1a0d1fbb7659839ed994c261c887ac6", + "01899428b0238563ec0e219bd96221aa9c2c24fd0287c174e147d5bab2a72ce2", + "d998a18380d0ff7a772e32b6a9d92236c0634965ae5f51a0a18e9136320554ef", + "85e95bada40bbf15df5929c8f052f6dc1eb12322c321441fa5aa009ac40f19d2", + "1b0dee271db263e03a7da56364773e89b1ba2153e7ccf0d4c1c80797eef8478c", + "19c80c35d5322c290c0ac68bd80507b826b17b6a9fca6f14ba5d054b573fb5e4", + "f9a4ccfad5e6c49c75d254d3bdb196c37731b99e99315551b6de111da09fb36e", + "edb417ef42cccd22f1e6f6fc6dc66c2c1217a155fab18c1ceb494f33c6e03c5d", + "75c25c7fd1f06d5d63e3265c3eb35c0e05aedaeac7e5b085285ddfab34f0a83d", + "92b420a8508fed0b94227f331aec6d6593444ff889724197973c89df609f504b", + "f9305e5fcbe1a303702388aaffb9a2cfd1b246a1db77bbd393b48a0276b54d54", + "f5eb58e2dc2fb8afb00508d1c407453f1e36a7a8cfa2e67006aad545a8558f63", + "67a7f5340f42fe61534716aa6b5fff1e04e31afb355b0431e2f61363ceef9095", + "4f1588d77167028e76db46ce3d0abb8722e02a8b1900a73d7bc0e1fef6c841be", + "456d721f9ea96d2cd7e60cec26eb294e897427bffa6a4c3bb25acfdc086173bf", + "eb68c506de42f1b59ec0ab7273872f78b0eee5d2ef57a09ece87b37c342fecda", + "0ffa190c414ffbb75a50853e9167f10778aca7fd7ac10d6b7178708812e143d2", + "c29a75edd34b55322b79c38a1a44be6e43e737539da389000b4d8b6e00d53c38", + "858b16eed193442d2ed01fa8687a5052d45ae27ef0fe285252bc7e734879497f", + "5bb96e0791ac797516e5fec6b70b469b1d1fd05bdd58c7d212b6a77af9bdff84", + "f141f208343ddeeb9da8797a2e15850979e71a1bbe69b225652fedb00c5e4987", + "a206757d3d27493d8ce80ed84ae907d283f7db7bf057aaccc182a15809b847b5" + ], + "txDetails": { + "4bd73f5b3e2f833e2922a62816d7fac391e7ecc3f628c7f15964efb64c4868fc": { + "hex": "02000000000101193855a716b4149420373dffa67ba2a16f4c696d7f257afeb2976ddd4902a0bc0100000017160014ef97a680f7d7ee02181749ed80b1bf23c6ae399efeffffff02255552000000000017a914f3346caa9e5349158cc18368bb72dd0c1790350a87f04e4800000000001976a914070628f88d48ef88034e967e582f57ecfad8c03788ac024830450221009dab05b240a5ae78a295f6a2c95e163691dc652c2d1c09cd34f8c8fcbfbb2677022019f53e52a4435f6038b99ec9f00854bd9de9ef84bf649013fc30efec1e26538a012103788b41f06266c5a98fb07af5f5fca21375aad9a3ae11fc9ae826cb48ee6b08aabc120800", + "txid": "4bd73f5b3e2f833e2922a62816d7fac391e7ecc3f628c7f15964efb64c4868fc", + "blocktime": 1529915213, + "time": 1529915213, + "locktime": 529084, + "vin": [ + { + "txid": "bca00249dd6d97b2fe7a257f6d694c6fa1a27ba6ff3d37209414b416a7553819", + "vout": 1, + "sequence": 4294967294, + "scriptSig": { + "hex": "160014ef97a680f7d7ee02181749ed80b1bf23c6ae399e" + } + } + ], + "vout": [ + { + "value": 0.05395749, + "n": 0, + "scriptPubKey": { + "hex": "a914f3346caa9e5349158cc18368bb72dd0c1790350a87" + } + }, + { + "value": 0.04738800, + "n": 1, + "scriptPubKey": { + "hex": "76a914070628f88d48ef88034e967e582f57ecfad8c03788ac" + } + } + ] + }, + "faef230df22406f367ba2e838b16eca0b581249a4476acc1a978613816dbec02": { + "hex": "0200000002a73d71157ae5f4372fe4624681bd72946a026e87a90cb2f307675146d5883941000000006a47304402202a6339b584730131f07c0c69ea40f08bc5c44cb161036509d2d0bef103c178c702206c0536316244acfdb0a27bf9a2ba4a6830b19ddc0fafd92027619dd4aa290bf1012102964e49b139cf408a30d4fc15e079789491689be74d63797e6bcbbe4191c8b691fefffffff9709ad0025e3968919c638559d00f8c8240b9b26a6624cc008548047e7af488010000006a47304402201cac13c2cbac8e536bc922462f810ffc086e8cf4a51a7f73d8d08aaf56372d6902206cc3518b6024d9b7c4f2f30e5dbb954f6d4d77e6b76eccc1081a8ed505892a7001210209fa85c88fb0b628305a169ca62a103c0da2cace04300810ae57755ef31caae9feffffff02ea3a0f00000000001976a9143e3fc495d359f2d346af7b42f70ddc7bb4981c1788ac40c06503000000001976a914f4274a0adee47dfab83664493bf252e3da0b5f5988acfd120800", + "txid": "faef230df22406f367ba2e838b16eca0b581249a4476acc1a978613816dbec02", + "blocktime": 1529915213, + "time": 1529915213, + "locktime": 529149, + "vin": [ + { + "txid": "413988d546516707f3b20ca9876e026a9472bd814662e42f37f4e57a15713da7", + "vout": 0, + "sequence": 4294967294, + "scriptSig": { + "hex": "47304402202a6339b584730131f07c0c69ea40f08bc5c44cb161036509d2d0bef103c178c702206c0536316244acfdb0a27bf9a2ba4a6830b19ddc0fafd92027619dd4aa290bf1012102964e49b139cf408a30d4fc15e079789491689be74d63797e6bcbbe4191c8b691" + } + }, + { + "txid": "88f47a7e04488500cc24666ab2b940828c0fd05985639c9168395e02d09a70f9", + "vout": 1, + "sequence": 4294967294, + "scriptSig": { + "hex": "47304402201cac13c2cbac8e536bc922462f810ffc086e8cf4a51a7f73d8d08aaf56372d6902206cc3518b6024d9b7c4f2f30e5dbb954f6d4d77e6b76eccc1081a8ed505892a7001210209fa85c88fb0b628305a169ca62a103c0da2cace04300810ae57755ef31caae9" + } + } + ], + "vout": [ + { + "value": 0.00998122, + "n": 0, + "scriptPubKey": { + "hex": "76a9143e3fc495d359f2d346af7b42f70ddc7bb4981c1788ac" + } + }, + { + "value": 0.57000000, + "n": 1, + "scriptPubKey": { + "hex": "76a914f4274a0adee47dfab83664493bf252e3da0b5f5988ac" + } + } + ] + } + } +} diff --git a/bchain/tests/rpc/testdata/Dash.json b/bchain/tests/rpc/testdata/Dash.json new file mode 100644 index 00000000..150e7d51 --- /dev/null +++ b/bchain/tests/rpc/testdata/Dash.json @@ -0,0 +1,58 @@ +{ + "blockHeight": 894503, + "blockHash": "0000000000000026e2b7c7bb478f0ee846dd976ac6b97c3f3f7c8c65beab88a4", + "blockTxs": [ + "6ea3a7fee4c40170d8782719d6fbeafd4cabb830f880d91bcf34811ad79e57bb", + "c269940d8e46d94ff61a4adec8aa6dfb13803723a95a5b61c7831d3aea308cbc", + "311d88d267dc099aacaeefba86770918d1f64c2b3f0db740336c48443d76930a", + "8fb04b7aa96faf585395160165b8aca332033b8eded505092aaca0e06805ba10", + "e28b7241432cc9ed3ec57136b662b354a6b32a08b8c2b265aebc08e8cc3578a5", + "677a619d342262fee2ade09a03318322c15b40878583975794d39c63a1e8584f", + "5f2aeacf8a93a7f8410839270eb6a94f659e5eef66e757b4e9ffe58c49cad0b9", + "b56c423e9a84abb50c145591788f1e2539aa6f7dde52ab700b45149546a78670", + "37478c09354bcdd650505e325699732d4c6aaec87f6bd696a59f1336b153a3d7", + "8be9dc7f41aa982f70ba90281564265e1f92f7bcfc9c75c1e2c9abbbd1a81e87", + "b85d5809e16100937072c88fc888206079c7105e1acc752159b6fe795332eb83", + "ad2488e0604eb39ffac7ae0eee32ab4e2e97d2f25547d25d25865f512236e683", + "62d1a3634b10512d1df5282d785bbcc765af3bbdf21490927f2881293d01636f", + "5608945bf9bb1ed422b3eb03719aa9a067238d60b2e832ee107e63a9baba5045", + "173badd5c5eedf889868b27e627d301d7e47dcbf3ced3f9caafa958d0c29bc3e", + "452237bb02aee6dbca4952e2d9f51ba475a7c1b09ab01bf649b72735610fbf2a", + "e7186be218879aea9ea32dc8e2ae63f390c7fcb9b755de1218935919f9377626" + ], + "txDetails": { + "311d88d267dc099aacaeefba86770918d1f64c2b3f0db740336c48443d76930a": { + "hex": "010000000123bd8250d890b3150559a2cc761e50e62440453ca3e24f34a19e088ca82488a7010000006b483045022100b1aa32099a83bfb0c2d0b081eac5ecc8b6e49fac08aebdce025ef43c74615ca002203105c02194805f00c8ac746f1b19e71b4fc4c8ddf214a61e0db543da7099e6d3012103c064d95430c38e9db6d9305075c32dbc22c24a108d8e5be47a74e0b67845debcfeffffff0264d5fb00000000001976a91456354204e7505cb7f4de7c37ffb32ff25b41cd6c88acd4205a03000000001976a914f32332d32e254176014b41872dadd0f1e6d8378688ac00000000", + "txid": "311d88d267dc099aacaeefba86770918d1f64c2b3f0db740336c48443d76930a", + "blocktime": 1530189699, + "time": 1530189699, + "locktime": 0, + "vin": [ + { + "txid": "a78824a88c089ea1344fe2a33c454024e6501e76cca2590515b390d85082bd23", + "vout": 1, + "sequence": 4294967294, + "scriptSig": { + "hex": "483045022100b1aa32099a83bfb0c2d0b081eac5ecc8b6e49fac08aebdce025ef43c74615ca002203105c02194805f00c8ac746f1b19e71b4fc4c8ddf214a61e0db543da7099e6d3012103c064d95430c38e9db6d9305075c32dbc22c24a108d8e5be47a74e0b67845debc" + } + } + ], + "vout": [ + { + "value": 0.16504164, + "n": 0, + "scriptPubKey": { + "hex": "76a91456354204e7505cb7f4de7c37ffb32ff25b41cd6c88ac" + } + }, + { + "value": 0.56238292, + "n": 1, + "scriptPubKey": { + "hex": "76a914f32332d32e254176014b41872dadd0f1e6d8378688ac" + } + } + ] + } + } +} diff --git a/bchain/tests/rpc/testdata/Namecoin.json b/bchain/tests/rpc/testdata/Namecoin.json new file mode 100644 index 00000000..4e1193cd --- /dev/null +++ b/bchain/tests/rpc/testdata/Namecoin.json @@ -0,0 +1,70 @@ +{ + "blockHeight": 404680, + "blockHash": "920fe53b840111f7e593d93ba58dc54e043e10f8fa4a678e86a98f5cb5b29614", + "blockTxs": [ + "80b8477d10df9ece7d8dde2d30817e2855af1fb66b7a9ac860e592118ae33f5f", + "afcd8e3638b11b1ce52055474dcce78c4129e95ebee3305574acda48deea8a65", + "6ab2278f25fe3ce914fb49ad79679cdb337c0d38211a865db126ca90c6850a60", + "88628abcb7014532daa9a084998e2f770c92e81833f4cc419e8da17bdea29a2e", + "cf04d4d9f1ebcec2d005922628af77dad24d7d735b56befc8b60014259ebfe0f", + "161ea9e2056c86559d5e593554dbe90c8ae8e99b2b38ce4f78866b4d586bddfc", + "89866c18f8effe8f7b15bb2973907ec50d5e2e5d79d9c8054d2f286b66c7a318", + "7269a55d870661d51611e91afd5963a2df69cb7cb70e55a0019128db42c07393", + "e94ff789e7cea0a9935baae202018d41ab238e4536e397d194f307afc126fd54", + "f144f6346a8ce5f5f350753738958b716845fdd76841f2fb691b74206de20099", + "2b4f85cead2f60224deedf8b9a65312221ccd531c3324211a5ab7bd1e4b3592e", + "c1b3ffdae37b61052bd7f7bd14b697402208bc6eeedffd3ef05e3b8eeeccf623", + "25562c32931c4a5b045076609c211c0d9d9f50dd49d669c49cabd50473677fc0", + "1e41bdcb5bc4038cd5ca6fd8fcfa115ce5ed8b4bb26849d8129a8f8cd1493f28", + "5d84a38142d07de023114252ac8efd5172c8334818d95c71b8053544ce57f817", + "7fe0c2a2746c1237a9b1af7a595bf56ce23bf834ac0c2a6d29b480a0a4fbd524", + "784104089ce84977bb235b2509651677a84789c415d60eccc9dbf77be585ad9c", + "f00c1aef90779f58ffe451ce026ab491c1750e7eedecfb65925f46b971507f88", + "3b9c23fd6730cf2e11bc9f009db6f21f35df6b50941a46fc0a83cff423dd0695", + "7c6f996288a7d82df333b897301267519d033d889c8490b30785d526efe3e36d", + "fb8f9c1e3139f389ae7e21fd66bd506ae749cb303a1838b2738a4f8c63096c2b", + "4cdd7b9596862643df7c63a5b0b0e2deaa843e8251bfc60716b94ce0cb656660", + "435880f0d752539150dd828ebe1e4fb2ef92b3269b160278b3b98248c22036fd", + "9a2c3c096d630c1abf2b3fa0da367d954f2213ad5d8136375d42de3cc98132d1", + "cff4f408645e25f3f093d42684449fc51b31e897213bd98ebace7d49acdb5f4b", + "be1370f1e514fbb0d2345ee28d274081d56267bfddc6aa64090e3af4fcce6310", + "e422f60e56f36a03e263d8f812a99dcbc3c790f051a59ee5604e1aff97143b71", + "5082cc9765402eb1ca84273adcd264a9fb44cc427b921e5e776252eca2c6584a", + "08eb38fe093951404debe36ccc0e528dde6ee983c9d6f5d6752bcd160748fb7f" + ], + "txDetails": { + "08eb38fe093951404debe36ccc0e528dde6ee983c9d6f5d6752bcd160748fb7f": { + "hex": "010000000101292738408181cc445a937124bad53f0c1bfeff9e7fc6fb3f1713a6f74f3a22020000006b483045022100bc7c33f785866e688e7de7cdf385dd710159e9300e7c2702dcb556433c635e4f02202c9fa4659db2648061a14ef9108424866116695367d9042e7c1234a4556e900c012103fbb34dd0aca298fb23ba79af2c007880e593b6832e75784cdba1661f110f751efeffffff02a0870300000000001976a9145090f77ac9d008d11fe1da3283486b05a15920b688ac2827760c000000001976a91404a56a80df5913d9a65095d2498db77ad3bd690f88acc62c0600", + "txid": "08eb38fe093951404debe36ccc0e528dde6ee983c9d6f5d6752bcd160748fb7f", + "blocktime": 1530003649, + "time": 1530003649, + "locktime": 404678, + "vin": [ + { + "txid": "223a4ff7a613173ffbc67f9efffe1b0c3fd5ba2471935a44cc81814038272901", + "vout": 2, + "sequence": 4294967294, + "scriptSig": { + "hex": "483045022100bc7c33f785866e688e7de7cdf385dd710159e9300e7c2702dcb556433c635e4f02202c9fa4659db2648061a14ef9108424866116695367d9042e7c1234a4556e900c012103fbb34dd0aca298fb23ba79af2c007880e593b6832e75784cdba1661f110f751e" + } + } + ], + "vout": [ + { + "value": 0.00231328, + "n": 0, + "scriptPubKey": { + "hex": "76a9145090f77ac9d008d11fe1da3283486b05a15920b688ac" + } + }, + { + "value": 2.09069864, + "n": 1, + "scriptPubKey": { + "hex": "76a91404a56a80df5913d9a65095d2498db77ad3bd690f88ac" + } + } + ] + } + } +} diff --git a/bchain/tests/rpc/testdata/Vertcoin.json b/bchain/tests/rpc/testdata/Vertcoin.json new file mode 100644 index 00000000..021cdc2a --- /dev/null +++ b/bchain/tests/rpc/testdata/Vertcoin.json @@ -0,0 +1,94 @@ +{ + "blockHeight": 952235, + "blockHash": "b2787dd022e3aa65b63dbf08af2c9bb4d4a362d95e3328c02743a5c8d75acb36", + "blockTxs": [ + "366eca05fa8579465d8822ad6462762120b26239201a34981e5f9d9efac3cc31", + "e74c247a5a77d4edd96a5dbb2930c74d9ab550affde991731f78f3e3a2f4b559", + "84f9d1fb25882a8eacad3ba83ff6819531c1c489b176273e76d1e53ecf72e207", + "65a7e80d2f9b21d0003bac50dc529ceab842fb89208e7bf2b7fc20313ee6c999" + ], + "txDetails": { + "e74c247a5a77d4edd96a5dbb2930c74d9ab550affde991731f78f3e3a2f4b559": { + "hex": "0200000001241682f3f9b341163babb2e6a41b43699f9dee63687389c55965d1bd0404c78e000000006b483045022100f0bf400ae5245d99f168d0c0da054660fb22615c94c8ee00c1eebef86b32befc022027ceb32aa210563d2600d6a33f32158e17b5d64eed9829c67dd967d86108db9901210259921142e1b9e7b28e7cbb0449ca5753deeea3fb7f6be470292565cf1ef86d74feffffff024b43f500000000001976a914a58a32fdf2286f90c7a4e9e1c92eb57c4936bacf88ac7e619b00000000001976a914108f72087bfc3131c7c09feba913bf66b652f5c188aca8870e00", + "txid": "e74c247a5a77d4edd96a5dbb2930c74d9ab550affde991731f78f3e3a2f4b559", + "blocktime": 1529932850, + "time": 1529932850, + "locktime": 952232, + "vin": [ + { + "txid": "8ec70404bdd16559c589736863ee9d9f69431ba4e6b2ab3b1641b3f9f3821624", + "vout": 0, + "sequence": 4294967294, + "scriptSig": { + "hex": "483045022100f0bf400ae5245d99f168d0c0da054660fb22615c94c8ee00c1eebef86b32befc022027ceb32aa210563d2600d6a33f32158e17b5d64eed9829c67dd967d86108db9901210259921142e1b9e7b28e7cbb0449ca5753deeea3fb7f6be470292565cf1ef86d74" + } + } + ], + "vout": [ + { + "value": 0.16073547, + "n": 0, + "scriptPubKey": { + "hex": "76a914a58a32fdf2286f90c7a4e9e1c92eb57c4936bacf88ac" + } + }, + { + "value": 0.10183038, + "n": 1, + "scriptPubKey": { + "hex": "76a914108f72087bfc3131c7c09feba913bf66b652f5c188ac" + } + } + ] + }, + "65a7e80d2f9b21d0003bac50dc529ceab842fb89208e7bf2b7fc20313ee6c999": { + "hex": "0100000003748dcb015356e8d6281ecec18c308a8198e20555c9b254a1addd2cd67ddb6557000000006b4830450221009bf690117c8624bc97849c49ebc37e02664545761d1d975a4a6636e462a75ecf02206b67bfd773a84a7a6f04905d7b358ee96f0f436674c49f6968b19654390f5763012103ec0f6a189b51640672d67f3b41a06c9b6b01e5c65c4ef56dda7581d1ca6ad2ebffffffff70361357af324b196f1ad09297d1a33a7b42f6a0cf0c54526a712be12364cb9c010000006a473044022007170c7944cee3facff0949fadfb85739dcca9e9dc9cde9cdf86b166169b6d75022072d329810a84d3a997630e742f638bade7734d0f6e2c45cc4c2c6a0797c3bb1f0121024783018d0b2d63a455bb9d71997b458c9dc6138dc38d32ce1cb5dce69699e3d9ffffffff0eb97971739b2d8a359a48bf2099c25976d876ed0b727f00315aa04a6faf500d000000006a4730440220201f8bccbae07bc065faa5c2602b80ed3b54b5d62c59f769bd70ccca34ba343e022013b70d43fcdb673d089265348548c107a1e25acdafeb7dc54ea3d367a7b8ab16012103286074c7bde46a2d5caa130669fe45146b8a3100bcd6f4cd1c80ae7d68e67babffffffff026cbae898020000001976a91413ef0a6e4c098b740aa38d13f5e12a8f9790769888ac04815402000000001976a9140f1800503d3cfe374df1200b3387bcbb43a874e688aca9870e00", + "txid": "65a7e80d2f9b21d0003bac50dc529ceab842fb89208e7bf2b7fc20313ee6c999", + "blocktime": 1529932850, + "time": 1529932850, + "locktime": 952233, + "vin": [ + { + "txid": "5765db7dd62cddada154b2c95505e298818a308cc1ce1e28d6e8565301cb8d74", + "vout": 0, + "sequence": 4294967295, + "scriptSig": { + "hex": "4830450221009bf690117c8624bc97849c49ebc37e02664545761d1d975a4a6636e462a75ecf02206b67bfd773a84a7a6f04905d7b358ee96f0f436674c49f6968b19654390f5763012103ec0f6a189b51640672d67f3b41a06c9b6b01e5c65c4ef56dda7581d1ca6ad2eb" + } + }, + { + "txid": "9ccb6423e12b716a52540ccfa0f6427b3aa3d19792d01a6f194b32af57133670", + "vout": 1, + "sequence": 4294967295, + "scriptSig": { + "hex": "473044022007170c7944cee3facff0949fadfb85739dcca9e9dc9cde9cdf86b166169b6d75022072d329810a84d3a997630e742f638bade7734d0f6e2c45cc4c2c6a0797c3bb1f0121024783018d0b2d63a455bb9d71997b458c9dc6138dc38d32ce1cb5dce69699e3d9" + } + }, + { + "txid": "0d50af6f4aa05a31007f720bed76d87659c29920bf489a358a2d9b737179b90e", + "vout": 0, + "sequence": 4294967295, + "scriptSig": { + "hex": "4730440220201f8bccbae07bc065faa5c2602b80ed3b54b5d62c59f769bd70ccca34ba343e022013b70d43fcdb673d089265348548c107a1e25acdafeb7dc54ea3d367a7b8ab16012103286074c7bde46a2d5caa130669fe45146b8a3100bcd6f4cd1c80ae7d68e67bab" + } + } + ], + "vout": [ + { + "value": 111.55323500, + "n": 0, + "scriptPubKey": { + "hex": "76a91413ef0a6e4c098b740aa38d13f5e12a8f9790769888ac" + } + }, + { + "value": 0.39092484, + "n": 1, + "scriptPubKey": { + "hex": "76a9140f1800503d3cfe374df1200b3387bcbb43a874e688ac" + } + } + ] + } + } +} diff --git a/bchain/tests/rpc/testdata/Zcash.json b/bchain/tests/rpc/testdata/Zcash.json new file mode 100644 index 00000000..6b620537 --- /dev/null +++ b/bchain/tests/rpc/testdata/Zcash.json @@ -0,0 +1,130 @@ +{ + "blockHeight": 349410, + "blockHash": "000000000101b45343aeda139d06d7f188393a5cf4adabfa191cb1828d67f6bd", + "blockTxs": [ + "6ebf0114454ba776f878cf726be3cb65964b21fad8dfca5d2ee69bd4a32cfa97", + "3de894528d5f8dbe14f726244be70a88f9b738020215c91b2893fa5a46f48c14", + "80d496a614f65e0933a5eb1107ff322d6c03fca8f1d3bfab2f6522291c8de612", + "262f2bd9b79f569ffebef1cb0f9326fb07d389543605d311dc47740b730132c8", + "c84493f0ab4335447aeb94fe80b6c48675e4a2320dbf4b6f8cb71352ca25e645", + "7ee2c521ec90956da6f923501486305e3280729cf251a4ba30ecbd9a227297b0", + "5baabe317a29bee55738a3b52eab7059e4594cd0ca19c74be11f91c764592c5f", + "b9bff7782e83daa72750c5dd7ac73b8d274ead198804f4867ee28d8381ef3a07", + "753666801b1c8513feaa447e8afa92a329e4dfd93291124fd31cf17e235b41c3", + "896f962ef7a942362760aae0c7f9e951da7961398cf8bafa6ef4bec7821b4225", + "a162ce37f2469e8e624175d1cbc2105badb56f10c114c1339b3528e9701b6925", + "d97b85f5e9c1e1ac184609d1d7336902ca1272228400ce8ed82ecc0ec35bab75" + ], + "txDetails": { + "80d496a614f65e0933a5eb1107ff322d6c03fca8f1d3bfab2f6522291c8de612": { + "hex": "030000807082c403010cb33c71311a437b999c7ed0adbae487cbbf73297f7283e6b0a10f9bc2aa9f9c000000006a473044022037d365e3e200a5b75738baddb95262bede1786741bf013278652912153e594d802202cc9befcaadf78318317b0741f145f736af29dae6fc71c53cbfb63b5edadc572012103a294809dd3460af72a2157247e9bf5b958db7a6cda52c447673c85ed5b4be04afeffffff027ecdc609000000001976a914afa0f9a6a73874495cb8a7657c056d19a4d9a28088ace3d46b29010000001976a9146126ed5dadfa31ed09fe661d25a11f4e903cf60a88acd7540500f654050000", + "txid": "80d496a614f65e0933a5eb1107ff322d6c03fca8f1d3bfab2f6522291c8de612", + "blocktime": 1530264033, + "time": 1530264033, + "locktime": 349399, + "vin": [ + { + "txid": "9c9faac29b0fa1b0e683727f2973bfcb87e4baadd07e9c997b431a31713cb30c", + "vout": 0, + "sequence": 4294967294, + "scriptSig": { + "hex": "473044022037d365e3e200a5b75738baddb95262bede1786741bf013278652912153e594d802202cc9befcaadf78318317b0741f145f736af29dae6fc71c53cbfb63b5edadc572012103a294809dd3460af72a2157247e9bf5b958db7a6cda52c447673c85ed5b4be04a" + } + } + ], + "vout": [ + { + "value": 1.64023678, + "n": 0, + "scriptPubKey": { + "hex": "76a914afa0f9a6a73874495cb8a7657c056d19a4d9a28088ac", + "addresses": ["t1ZtF6fAXmgtaAAnWKCoRC2fGjfShrsp1mh"] + } + }, + { + "value": 49.89900003, + "n": 1, + "scriptPubKey": { + "hex": "76a9146126ed5dadfa31ed09fe661d25a11f4e903cf60a88ac", + "addresses": ["t1SjJBeqRukybZMJoGvzr6estEKQMsnQVEi"] + } + } + ] + }, + "7ee2c521ec90956da6f923501486305e3280729cf251a4ba30ecbd9a227297b0": { + "hex": "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", + "txid": "7ee2c521ec90956da6f923501486305e3280729cf251a4ba30ecbd9a227297b0", + "blocktime": 1530264033, + "time": 1530264033, + "locktime": 0, + "vin": [ + { + "txid": "4440c8e9d5b57da7ca0fb3f62ec13f392267aeb797c123bb01e850adf8573dd0", + "vout": 1, + "sequence": 4294967294, + "scriptSig": { + "hex": "473044022005cfef2a84a0490a19b6215c763808343ee1a297e0a2656362cfbdd0742d80540220166fa467e7ecf0c01db946e80dcffc640d204e661bfe892596aab5ba5c18e2fd01210304668b7d8f195822a56898b7dc331dd0a3077b94901ab4111490111903747b70" + } + }, + { + "txid": "44cd59c22af661608c7bc5f8bab7322e6f69dc62d88052440a4dddc65fe38f32", + "vout": 0, + "sequence": 4294967294, + "scriptSig": { + "hex": "47304402203e9715d825367f1e6f0af698403f2e20c38215a23a7cfefa2863f96005bb907d02201646b4860583ec77fe21e4f2895c61d111a817ac4cc7aa18343a318965f908100121037d4a056edd1419bf1efc95f02557b432e81cbfd8877450aef07f22e4370378fb" + } + }, + { + "txid": "ce39b62ed460762ebe8dedee279cbccd7eeac092da9f9bc066027cdf9a693eb6", + "vout": 230, + "sequence": 4294967294, + "scriptSig": { + "hex": "483045022100a53cf85cff3dd727a176dbd70ffeb3e8b1301f116d7b284322f0b0b18ecaf94b02201292af8f1493521ade1d85caa05f2d832a0fb8f05ce286515a2ef9ea76206df50121037d4a056edd1419bf1efc95f02557b432e81cbfd8877450aef07f22e4370378fb" + } + }, + { + "txid": "379c505fb6273257653156ed1dfea5f88900ba396f549d8b07faba93f62dd91a", + "vout": 57, + "sequence": 4294967294, + "scriptSig": { + "hex": "47304402204607c6ebd7dca117de8e1224f6c1395684c4b7160584aac27fa64feb2ec034be022023995fd5fa02c802e3ee1b9c1dd1b1f4fbf4095554e8ae044225d63c01fd2a5e0121037d4a056edd1419bf1efc95f02557b432e81cbfd8877450aef07f22e4370378fb" + } + }, + { + "txid": "00d55f37d6d6c72134ad7303caa005f7755d5ad55a6452c0e8281f01bf5715d0", + "vout": 1, + "sequence": 4294967294, + "scriptSig": { + "hex": "47304402205e784f982ca17aceb517a411be3e83cf341137443f68fe0c3d0da174707ad41e02207ff2a726ac1dfea75562ef1158e154bf6bb2aa15c6049b41a30c5fc39f76757a0121037d4a056edd1419bf1efc95f02557b432e81cbfd8877450aef07f22e4370378fb" + } + }, + { + "txid": "365f2f9014dbf5aac2b00b6230d213776b40815512f89be422fca96d81bec195", + "vout": 144, + "sequence": 4294967294, + "scriptSig": { + "hex": "483045022100cc5a0fa9744e733db784bfa886fe4f357685dc2808724f711a1c7c0cd6450e82022021ef44520216108c6edd6965ce4696d67001a32b8e8c75d8f5e44aa2ae84b68b0121037d4a056edd1419bf1efc95f02557b432e81cbfd8877450aef07f22e4370378fb" + } + }, + { + "txid": "ce7d1a0b1be6f2e7fe9566171547bb255e56184bb9bb1ed72fa56962d8ad604a", + "vout": 0, + "sequence": 4294967294, + "scriptSig": { + "hex": "47304402204ab729c42d2b405fe87dfc84a581b468636012a5db8b8307b7553c453edd31d9022047d03441fb530323a73961bad3e1ba215b4e5c631d76482a72764153e17a0e260121037d4a056edd1419bf1efc95f02557b432e81cbfd8877450aef07f22e4370378fb" + } + } + ], + "vout": [ + { + "value": 2.06852275, + "n": 0, + "scriptPubKey": { + "hex": "76a914b461a4bb45a24995566f7ea86c6873bc6995b98f88ac", + "addresses": ["t1aKNcFdt396ir1bsdDdjuwQj63JHRvMqP1"] + } + } + ] + } + } +} diff --git a/configs/bgold.json b/configs/bgold.json index b72edb5d..52d9c098 100644 --- a/configs/bgold.json +++ b/configs/bgold.json @@ -7,7 +7,7 @@ "rpcTimeout": 25, "parse": true, "zeroMQBinding": "tcp://127.0.0.1:38335", - "subversion": "/Bitcoin Gold:0.15.0.2/", + "subversion": "/Bitcoin Gold:0.15.1/", "mempoolWorkers": 8, "mempoolSubWorkers": 2, "blockAddressesToKeep": 300 diff --git a/contrib/backends/bgold/Makefile b/contrib/backends/bgold/Makefile index b45b584c..e72f706a 100644 --- a/contrib/backends/bgold/Makefile +++ b/contrib/backends/bgold/Makefile @@ -1,5 +1,5 @@ -BGOLD_VERSION := 0.15.0 -BUILD_VERSION := .2 +BGOLD_VERSION := 0.15.1 +BUILD_VERSION := all: wget https://github.com/BTCGPU/BTCGPU/releases/download/v${BGOLD_VERSION}${BUILD_VERSION}/bitcoin-gold-${BGOLD_VERSION}-x86_64-linux-gnu.tar.gz diff --git a/contrib/backends/bgold/debian/changelog b/contrib/backends/bgold/debian/changelog index c2eda095..2d66f9e2 100644 --- a/contrib/backends/bgold/debian/changelog +++ b/contrib/backends/bgold/debian/changelog @@ -1,3 +1,15 @@ +bgold (0.15.1-satoshilabs1) unstable; urgency=medium + + * Version 0.15.1 + + -- Martin Bohm Mon, 02 Jul 2018 14:15:16 +0200 + +bgold (0.15.1-rc1-satoshilabs1) unstable; urgency=medium + + * Version 0.15.1-rc1 + + -- Martin Bohm Fri, 29 Jun 2018 14:15:16 +0200 + bgold (0.15.0-satoshilabs2) unstable; urgency=medium * Renamed package and paths