modify config (#265)

* modify config

* modify bytom mainnet

diff --git a/blockchain/txbuilder/actions.go b/blockchain/txbuilder/actions.go
index 1b72c7d..ff83650 100644 (file)
--- a/blockchain/txbuilder/actions.go
+++ b/blockchain/txbuilder/actions.go
@@ -168,7 +168,7 @@ func (a *crossOutAction) Build(ctx context.Context, b *TemplateBuilder) error {
                return MissingFieldsError(missing...)
        }
 
                return MissingFieldsError(missing...)
        }
 

-       address, err := common.DecodeAddress(a.Address, &consensus.MainNetParams)
+       address, err := common.DecodeAddress(a.Address, &consensus.BytomMainNetParams)

        if err != nil {
                return err
        }
        if err != nil {
                return err
        }

diff --git a/blockchain/txbuilder/txbuilder_test.go b/blockchain/txbuilder/txbuilder_test.go
index 5176a9a..76035ed 100644 (file)
--- a/blockchain/txbuilder/txbuilder_test.go
+++ b/blockchain/txbuilder/txbuilder_test.go
@@ -88,7 +88,7 @@ func TestBuildIntra(t *testing.T) {
 }
 
 func newCrossOutAction(assetAmt bc.AssetAmount, redeemContract []byte) *crossOutAction {
 }
 
 func newCrossOutAction(assetAmt bc.AssetAmount, redeemContract []byte) *crossOutAction {

-       address, err := common.NewAddressWitnessPubKeyHash(redeemContract, &consensus.MainNetParams)
+       address, err := common.NewAddressWitnessPubKeyHash(redeemContract, &consensus.BytomMainNetParams)

        if err != nil {
                panic(err)
        }
        if err != nil {
                panic(err)
        }

diff --git a/common/address_test.go b/common/address_test.go
index f768173..b1b3d5b 100644 (file)
--- a/common/address_test.go
+++ b/common/address_test.go
@@ -24,8 +24,8 @@ func TestAddresses(t *testing.T) {
                // Segwit address tests.
                {
                        name:    "segwit mainnet p2wpkh v0",
                // Segwit address tests.
                {
                        name:    "segwit mainnet p2wpkh v0",

-                       addr:    "BM1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7K23GYYF",
-                       encoded: "bm1qw508d6qejxtdg4y5r3zarvary0c5xw7k23gyyf",
+                       addr:    "VP1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KPSCEPL",
+                       encoded: "vp1qw508d6qejxtdg4y5r3zarvary0c5xw7kpscepl",

                        valid:   true,
                        result: tstAddressWitnessPubKeyHash(
                                0,
                        valid:   true,
                        result: tstAddressWitnessPubKeyHash(
                                0,


@@ -43,8 +43,8 @@ func TestAddresses(t *testing.T) {
                },
                {
                        name:    "segwit mainnet p2wsh v0",
                },
                {
                        name:    "segwit mainnet p2wsh v0",

-                       addr:    "bm1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qk5egtg",
-                       encoded: "bm1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qk5egtg",
+                       addr:    "vp1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3ql5u263",
+                       encoded: "vp1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3ql5u263",

                        valid:   true,
                        result: tstAddressWitnessScriptHash(
                                0,
                        valid:   true,
                        result: tstAddressWitnessScriptHash(
                                0,


@@ -66,8 +66,8 @@ func TestAddresses(t *testing.T) {
                },
                {
                        name:    "segwit testnet p2wpkh v0",
                },
                {
                        name:    "segwit testnet p2wpkh v0",

-                       addr:    "tm1qw508d6qejxtdg4y5r3zarvary0c5xw7kw8fqyc",
-                       encoded: "tm1qw508d6qejxtdg4y5r3zarvary0c5xw7kw8fqyc",
+                       addr:    "tp1qw508d6qejxtdg4y5r3zarvary0c5xw7kvj35pt",
+                       encoded: "tp1qw508d6qejxtdg4y5r3zarvary0c5xw7kvj35pt",

                        valid:   true,
                        result: tstAddressWitnessPubKeyHash(
                                0,
                        valid:   true,
                        result: tstAddressWitnessPubKeyHash(
                                0,


@@ -85,8 +85,8 @@ func TestAddresses(t *testing.T) {
                },
                {
                        name:    "segwit testnet p2wsh v0",
                },
                {
                        name:    "segwit testnet p2wsh v0",

-                       addr:    "tm1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qqq379v",
-                       encoded: "tm1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qqq379v",
+                       addr:    "tp1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qayxglu",
+                       encoded: "tp1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qayxglu",

                        valid:   true,
                        result: tstAddressWitnessScriptHash(
                                0,
                        valid:   true,
                        result: tstAddressWitnessScriptHash(
                                0,


@@ -108,8 +108,8 @@ func TestAddresses(t *testing.T) {
                },
                {
                        name:    "segwit testnet p2wsh witness v0",
                },
                {
                        name:    "segwit testnet p2wsh witness v0",

-                       addr:    "tm1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesvkesyk",
-                       encoded: "tm1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesvkesyk",
+                       addr:    "tp1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvses3jwx7x",
+                       encoded: "tp1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvses3jwx7x",

                        valid:   true,
                        result: tstAddressWitnessScriptHash(
                                0,
                        valid:   true,
                        result: tstAddressWitnessScriptHash(
                                0,


@@ -132,19 +132,19 @@ func TestAddresses(t *testing.T) {
                // Unsupported witness versions (version 0 only supported at this point)
                {
                        name:  "segwit mainnet witness v1",
                // Unsupported witness versions (version 0 only supported at this point)
                {
                        name:  "segwit mainnet witness v1",

-                       addr:  "bm1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k7grplx",
+                       addr:  "vp1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k7grplx",

                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit mainnet witness v16",
                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit mainnet witness v16",

-                       addr:  "BM1SW50QA3JX3S",
+                       addr:  "VP1SW50QA3JX3S",

                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit mainnet witness v2",
                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit mainnet witness v2",

-                       addr:  "bm1zw508d6qejxtdg4y5r3zarvaryvg6kdaj",
+                       addr:  "vp1zw508d6qejxtdg4y5r3zarvaryvg6kdaj",

                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                        valid: false,
                        net:   &consensus.MainNetParams,
                },


@@ -157,49 +157,49 @@ func TestAddresses(t *testing.T) {
                },
                {
                        name:  "segwit invalid checksum",
                },
                {
                        name:  "segwit invalid checksum",

-                       addr:  "bm1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5",
+                       addr:  "vp1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5",

                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit invalid witness version",
                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit invalid witness version",

-                       addr:  "BM13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2",
+                       addr:  "VP13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2",

                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit invalid program length",
                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit invalid program length",

-                       addr:  "bm1rw5uspcuh",
+                       addr:  "vp1rw5uspcuh",

                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit invalid program length",
                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit invalid program length",

-                       addr:  "bm10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90",
+                       addr:  "vp10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90",

                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit invalid program length for witness version 0 (per BIP141)",
                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit invalid program length for witness version 0 (per BIP141)",

-                       addr:  "BM1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P",
+                       addr:  "VP1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P",

                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit mixed case",
                        valid: false,
                        net:   &consensus.MainNetParams,
                },
                {
                        name:  "segwit mixed case",

-                       addr:  "tm1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7",
+                       addr:  "tp1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7",

                        valid: false,
                        net:   &consensus.TestNetParams,
                },
                {
                        name:  "segwit zero padding of more than 4 bits",
                        valid: false,
                        net:   &consensus.TestNetParams,
                },
                {
                        name:  "segwit zero padding of more than 4 bits",

-                       addr:  "tm1pw508d6qejxtdg4y5r3zarqfsj6c3",
+                       addr:  "tp1pw508d6qejxtdg4y5r3zarqfsj6c3",

                        valid: false,
                        net:   &consensus.TestNetParams,
                },
                {
                        name:  "segwit non-zero padding in 8-to-5 conversion",
                        valid: false,
                        net:   &consensus.TestNetParams,
                },
                {
                        name:  "segwit non-zero padding in 8-to-5 conversion",

-                       addr:  "tm1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv",
+                       addr:  "tp1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv",

                        valid: false,
                        net:   &consensus.TestNetParams,
                },
                        valid: false,
                        net:   &consensus.TestNetParams,
                },

diff --git a/config/toml.go b/config/toml.go
index 9981566..6a1e129 100644 (file)
--- a/config/toml.go
+++ b/config/toml.go
@@ -27,23 +27,31 @@ api_addr = "0.0.0.0:9889"
 moniker = ""
 `
 
 moniker = ""
 `
 

-var soloNetConfigTmpl = `chain_id = "solonet"
+var mainNetConfigTmpl = `chain_id = "mainnet"
+[p2p]
+laddr = "tcp://0.0.0.0:56656"
+seeds = "52.82.28.25:56656,52.82.31.195:56656,52.82.31.247:56656"
+`
+
+var testNetConfigTmpl = `chain_id = "testnet"

 [p2p]
 [p2p]

-laddr = "tcp://0.0.0.0:46658"
+laddr = "tcp://0.0.0.0:56657"

 seeds = ""
 `
 
 seeds = ""
 `
 

-var vaporNetConfigTmpl = `chain_id = "vapor"
+var soloNetConfigTmpl = `chain_id = "solonet"

 [p2p]
 [p2p]

-laddr = "tcp://0.0.0.0:56656"
-seeds = "52.82.28.25:56656,52.82.31.195:56656,52.82.31.247:56656"
+laddr = "tcp://0.0.0.0:56658"
+seeds = ""

 `
 
 // Select network seeds to merge a new string.
 func selectNetwork(network string) string {
        switch network {
 `
 
 // Select network seeds to merge a new string.
 func selectNetwork(network string) string {
        switch network {

-       case "vapor":
-               return defaultConfigTmpl + vaporNetConfigTmpl
+       case "mainnet":
+               return defaultConfigTmpl + mainNetConfigTmpl
+       case "testnet":
+               return defaultConfigTmpl + testNetConfigTmpl

        default:
                return defaultConfigTmpl + soloNetConfigTmpl
        }
        default:
                return defaultConfigTmpl + soloNetConfigTmpl
        }

diff --git a/consensus/general.go b/consensus/general.go
index 8598e82..fe8e7b4 100644 (file)
--- a/consensus/general.go
+++ b/consensus/general.go
@@ -115,38 +115,44 @@ func VaporDPOSConfig() DPOSConfig {
 }
 
 // ActiveNetParams is the active NetParams
 }
 
 // ActiveNetParams is the active NetParams

-var ActiveNetParams = VaporNetParams
+var ActiveNetParams = MainNetParams

 
 // NetParams is the correspondence between chain_id and Params
 var NetParams = map[string]Params{
        "mainnet": MainNetParams,
 
 // NetParams is the correspondence between chain_id and Params
 var NetParams = map[string]Params{
        "mainnet": MainNetParams,

-       "wisdom":  TestNetParams,
-       "vapor":   VaporNetParams,
+       "testnet": TestNetParams,

        "solonet": SoloNetParams,
 }
 
        "solonet": SoloNetParams,
 }
 

-// MainNetParams is the config for bytom main-net
+// MainNetParams is the config for vapor-mainnet

 var MainNetParams = Params{
        Name:            "main",
 var MainNetParams = Params{
        Name:            "main",

-       Bech32HRPSegwit: "bm",
-       DefaultPort:     "46657",
-       DNSSeeds:        []string{"www.mainnetseed.bytom.io"},
-       Checkpoints:     []Checkpoint{},
+       Bech32HRPSegwit: "vp",
+       DefaultPort:     "56656",
+       DNSSeeds:        []string{"www.mainnetseed.vapor.io"},
+       BasicConfig: BasicConfig{
+               MaxBlockGas:                uint64(10000000),
+               MaxGasAmount:               int64(200000),
+               DefaultGasCredit:           int64(160000),
+               StorageGasRate:             int64(1),
+               VMGasRate:                  int64(200),
+               VotePendingBlockNumber:     uint64(10000),
+               CoinbasePendingBlockNumber: uint64(100),
+               CoinbaseArbitrarySizeLimit: 128,
+       },
+       DPOSConfig:  VaporDPOSConfig(),
+       Checkpoints: []Checkpoint{},
+       ProducerSubsidys: []ProducerSubsidy{
+               {BeginBlock: 1, EndBlock: 63072000, Subsidy: 15000000},
+       },

 }
 
 }
 

-// TestNetParams is the config for bytom test-net
+// TestNetParams is the config for vapor-testnet

 var TestNetParams = Params{
        Name:            "test",
 var TestNetParams = Params{
        Name:            "test",

-       Bech32HRPSegwit: "tm",
-       DefaultPort:     "46656",
-       DNSSeeds:        []string{"www.testnetseed.bytom.io"},
-       Checkpoints:     []Checkpoint{},
-}
-
-// VaporNetParams is the config for vapor-net
-var VaporNetParams = Params{
-       Name:            "vapor",
-       Bech32HRPSegwit: "vp",
+       Bech32HRPSegwit: "tp",
+       DefaultPort:     "56657",
+       DNSSeeds:        []string{"www.testnetseed.vapor.io"},

        BasicConfig: BasicConfig{
                MaxBlockGas:                uint64(10000000),
                MaxGasAmount:               int64(200000),
        BasicConfig: BasicConfig{
                MaxBlockGas:                uint64(10000000),
                MaxGasAmount:               int64(200000),


@@ -164,10 +170,11 @@ var VaporNetParams = Params{
        },
 }
 
        },
 }
 

-// SoloNetParams is the config for solo test-net
+// SoloNetParams is the config for vapor solonet

 var SoloNetParams = Params{
        Name:            "solo",
 var SoloNetParams = Params{
        Name:            "solo",

-       Bech32HRPSegwit: "sm",
+       Bech32HRPSegwit: "sp",
+       DefaultPort:     "56658",

        BasicConfig: BasicConfig{
                MaxBlockGas:                uint64(10000000),
                MaxGasAmount:               int64(200000),
        BasicConfig: BasicConfig{
                MaxBlockGas:                uint64(10000000),
                MaxGasAmount:               int64(200000),


@@ -197,3 +204,9 @@ func BlockSubsidy(height uint64) uint64 {
        }
        return 0
 }
        }
        return 0
 }

+
+// BytomMainNetParams is the config for bytom mainnet
+var BytomMainNetParams = Params{
+       Name:            "main",
+       Bech32HRPSegwit: "bm",
+}

diff --git a/federation/synchron/mainchain_keeper.go b/federation/synchron/mainchain_keeper.go
index e3ea7a3..0875fe3 100644 (file)
--- a/federation/synchron/mainchain_keeper.go
+++ b/federation/synchron/mainchain_keeper.go
@@ -224,13 +224,13 @@ func (m *mainchainKeeper) getCrossChainReqs(crossTransactionID uint64, tx *types
        switch {
        case segwit.IsP2WPKHScript(prog):
                if pubHash, err := segwit.GetHashFromStandardProg(prog); err == nil {
        switch {
        case segwit.IsP2WPKHScript(prog):
                if pubHash, err := segwit.GetHashFromStandardProg(prog); err == nil {

-                       fromAddress = wallet.BuildP2PKHAddress(pubHash, &vaporConsensus.MainNetParams)
-                       toAddress = wallet.BuildP2PKHAddress(pubHash, &vaporConsensus.VaporNetParams)
+                       fromAddress = wallet.BuildP2PKHAddress(pubHash, &vaporConsensus.BytomMainNetParams)
+                       toAddress = wallet.BuildP2PKHAddress(pubHash, &vaporConsensus.MainNetParams)

                }
        case segwit.IsP2WSHScript(prog):
                if scriptHash, err := segwit.GetHashFromStandardProg(prog); err == nil {
                }
        case segwit.IsP2WSHScript(prog):
                if scriptHash, err := segwit.GetHashFromStandardProg(prog); err == nil {

-                       fromAddress = wallet.BuildP2SHAddress(scriptHash, &vaporConsensus.MainNetParams)
-                       toAddress = wallet.BuildP2SHAddress(scriptHash, &vaporConsensus.VaporNetParams)
+                       fromAddress = wallet.BuildP2SHAddress(scriptHash, &vaporConsensus.BytomMainNetParams)
+                       toAddress = wallet.BuildP2SHAddress(scriptHash, &vaporConsensus.MainNetParams)

                }
        }
 
                }
        }
 

diff --git a/federation/synchron/sidechain_keeper.go b/federation/synchron/sidechain_keeper.go
index 8c53816..89a3bd9 100644 (file)
--- a/federation/synchron/sidechain_keeper.go
+++ b/federation/synchron/sidechain_keeper.go
@@ -230,11 +230,11 @@ func (s *sidechainKeeper) getCrossChainReqs(crossTransactionID uint64, tx *types
        switch {
        case segwit.IsP2WPKHScript(inputCP):
                if pubHash, err := segwit.GetHashFromStandardProg(inputCP); err == nil {
        switch {
        case segwit.IsP2WPKHScript(inputCP):
                if pubHash, err := segwit.GetHashFromStandardProg(inputCP); err == nil {

-                       fromAddress = wallet.BuildP2PKHAddress(pubHash, &consensus.VaporNetParams)
+                       fromAddress = wallet.BuildP2PKHAddress(pubHash, &consensus.MainNetParams)

                }
        case segwit.IsP2WSHScript(inputCP):
                if scriptHash, err := segwit.GetHashFromStandardProg(inputCP); err == nil {
                }
        case segwit.IsP2WSHScript(inputCP):
                if scriptHash, err := segwit.GetHashFromStandardProg(inputCP); err == nil {

-                       fromAddress = wallet.BuildP2SHAddress(scriptHash, &consensus.VaporNetParams)
+                       fromAddress = wallet.BuildP2SHAddress(scriptHash, &consensus.MainNetParams)

                }
        }
 
                }
        }
 


@@ -259,11 +259,11 @@ func (s *sidechainKeeper) getCrossChainReqs(crossTransactionID uint64, tx *types
                switch {
                case segwit.IsP2WPKHScript(outputCP):
                        if pubHash, err := segwit.GetHashFromStandardProg(outputCP); err == nil {
                switch {
                case segwit.IsP2WPKHScript(outputCP):
                        if pubHash, err := segwit.GetHashFromStandardProg(outputCP); err == nil {

-                               toAddress = wallet.BuildP2PKHAddress(pubHash, &consensus.MainNetParams)
+                               toAddress = wallet.BuildP2PKHAddress(pubHash, &consensus.BytomMainNetParams)

                        }
                case segwit.IsP2WSHScript(outputCP):
                        if scriptHash, err := segwit.GetHashFromStandardProg(outputCP); err == nil {
                        }
                case segwit.IsP2WSHScript(outputCP):
                        if scriptHash, err := segwit.GetHashFromStandardProg(outputCP); err == nil {

-                               toAddress = wallet.BuildP2SHAddress(scriptHash, &consensus.MainNetParams)
+                               toAddress = wallet.BuildP2SHAddress(scriptHash, &consensus.BytomMainNetParams)

                        }
                }
 
                        }
                }
 

diff --git a/p2p/discover/dht/dns_seeds_test.go b/p2p/discover/dht/dns_seeds_test.go
index 8856ad0..03e322e 100644 (file)
--- a/p2p/discover/dht/dns_seeds_test.go
+++ b/p2p/discover/dht/dns_seeds_test.go
@@ -26,39 +26,39 @@ func lookupHostErrIP(host string) ([]string, error) {
        return errAddr, nil
 }
 
        return errAddr, nil
 }
 

-var testCases = []struct {
-       chainID    string
-       lookupHost func(host string) (addrs []string, err error)
-       wantErr    error
-       wantAddr   []string
-}{
-       {
-               chainID:    "wisdom",
-               lookupHost: lookupHostNormal,
-               wantErr:    nil,
-               wantAddr:   []string{"1.2.3.4:46656", "5.6.7.8:46656"},
-       },
-       {
-               chainID:    "mainnet",
-               lookupHost: lookupHostNormal,
-               wantErr:    nil,
-               wantAddr:   []string{"11.22.33.44:46657", "55.66.77.88:46657"},
-       },
-       {
-               chainID:    "solonet",
-               lookupHost: lookupHostNormal,
-               wantErr:    errDNSSeedsEmpty,
-               wantAddr:   nil,
-       },
-       {
-               chainID:    "wisdom",
-               lookupHost: lookupHostErrIP,
-               wantErr:    errDNSTimeout,
-               wantAddr:   nil,
-       },
-}
-

 func TestQueryDNSSeeds(t *testing.T) {
 func TestQueryDNSSeeds(t *testing.T) {

+       testCases := []struct {
+               chainID    string
+               lookupHost func(host string) (addrs []string, err error)
+               wantErr    error
+               wantAddr   []string
+       }{
+               {
+                       chainID:    "testnet",
+                       lookupHost: lookupHostNormal,
+                       wantErr:    nil,
+                       wantAddr:   []string{"1.2.3.4:56657", "5.6.7.8:56657"},
+               },
+               {
+                       chainID:    "mainnet",
+                       lookupHost: lookupHostNormal,
+                       wantErr:    nil,
+                       wantAddr:   []string{"11.22.33.44:56656", "55.66.77.88:56656"},
+               },
+               {
+                       chainID:    "solonet",
+                       lookupHost: lookupHostNormal,
+                       wantErr:    errDNSSeedsEmpty,
+                       wantAddr:   nil,
+               },
+               {
+                       chainID:    "testnet",
+                       lookupHost: lookupHostErrIP,
+                       wantErr:    errDNSTimeout,
+                       wantAddr:   nil,
+               },
+       }
+

        for i, tc := range testCases {
                consensus.ActiveNetParams = consensus.NetParams[tc.chainID]
                addresses, err := QueryDNSSeeds(tc.lookupHost)
        for i, tc := range testCases {
                consensus.ActiveNetParams = consensus.NetParams[tc.chainID]
                addresses, err := QueryDNSSeeds(tc.lookupHost)

diff --git a/wallet/annotated.go b/wallet/annotated.go
index ef8cfc3..b6bf016 100644 (file)
--- a/wallet/annotated.go
+++ b/wallet/annotated.go
@@ -192,7 +192,7 @@ func (w *Wallet) BuildAnnotatedInput(tx *types.Tx, i uint32) *query.AnnotatedInp
 func (w *Wallet) getAddressFromControlProgram(prog []byte, isMainchain bool) string {
        netParams := &consensus.ActiveNetParams
        if isMainchain {
 func (w *Wallet) getAddressFromControlProgram(prog []byte, isMainchain bool) string {
        netParams := &consensus.ActiveNetParams
        if isMainchain {

-               netParams = &consensus.MainNetParams
+               netParams = &consensus.BytomMainNetParams

        }
 
        if segwit.IsP2WPKHScript(prog) {
        }
 
        if segwit.IsP2WPKHScript(prog) {