Add support for Qtum

chain/qtum/address.go

@@ -0,0 +1,82 @@
+package qtum
+
+// This is a copy of Bitcoin's version with btcsuite swapped to qtumsuite
+
+import (
+	"fmt"
+
+	"github.com/qtumproject/qtumsuite/chaincfg"
+	"github.com/qtumproject/qtumsuite"
+	"github.com/qtumproject/qtumsuite/base58"
+	"github.com/renproject/multichain/api/address"
+)
+
+// AddressEncodeDecoder implements the address.EncodeDecoder interface
+type AddressEncodeDecoder struct {
+	AddressEncoder
+	AddressDecoder
+}
+
+// NewAddressEncodeDecoder constructs a new AddressEncodeDecoder with the
+// chain specific configurations
+func NewAddressEncodeDecoder(params *chaincfg.Params) AddressEncodeDecoder {
+	return AddressEncodeDecoder{
+		AddressEncoder: NewAddressEncoder(params),
+		AddressDecoder: NewAddressDecoder(params),
+	}
+}
+
+// AddressEncoder encapsulates the chain specific configurations and implements
+// the address.Encoder interface
+type AddressEncoder struct {
+	params *chaincfg.Params
+}
+
+// NewAddressEncoder constructs a new AddressEncoder with the chain specific
+// configurations
+func NewAddressEncoder(params *chaincfg.Params) AddressEncoder {
+	return AddressEncoder{params: params}
+}
+
+// EncodeAddress implements the address.Encoder interface
+func (encoder AddressEncoder) EncodeAddress(rawAddr address.RawAddress) (address.Address, error) {
+	// Validate that the base58 address is in fact in correct format.
+	encodedAddr := base58.Encode([]byte(rawAddr))
+	if _, err := qtumsuite.DecodeAddress(encodedAddr, encoder.params); err != nil {
+		return address.Address(""), err
+	}
+
+	return address.Address(encodedAddr), nil
+}
+
+// AddressDecoder encapsulates the chain specific configurations and implements
+// the address.Decoder interface
+type AddressDecoder struct {
+	params *chaincfg.Params
+}
+
+// NewAddressDecoder constructs a new AddressDecoder with the chain specific
+// configurations
+func NewAddressDecoder(params *chaincfg.Params) AddressDecoder {
+	return AddressDecoder{params: params}
+}
+
+// DecodeAddress implements the address.Decoder interface
+func (decoder AddressDecoder) DecodeAddress(addr address.Address) (address.RawAddress, error) {
+	// Decode the checksummed base58 format address.
+	decoded, ver, err := base58.CheckDecode(string(addr))
+	if err != nil {
+		return nil, fmt.Errorf("checking: %v", err)
+	}
+	if len(decoded) != 20 {
+		return nil, fmt.Errorf("expected len 20, got len %v", len(decoded))
+	}
+
+	// Validate the address format.
+	switch ver {
+	case decoder.params.PubKeyHashAddrID, decoder.params.ScriptHashAddrID:
+		return address.RawAddress(base58.Decode(string(addr))), nil
+	default:
+		return nil, fmt.Errorf("unexpected address prefix")
+	}
+}

chain/qtum/address_test.go

@@ -0,0 +1 @@
+package qtum_test

chain/qtum/gas.go

@@ -0,0 +1,11 @@
+package qtum
+
+// I *Think* it is fine to simply use Bitcoin's estimator here
+
+import "github.com/renproject/multichain/chain/bitcoin"
+
+// GasEstimator re-exports bitcoin.GasEstimator.
+type GasEstimator = bitcoin.GasEstimator
+
+// NewGasEstimator re-exports bitcoin.NewGasEstimator.
+var NewGasEstimator = bitcoin.NewGasEstimator

chain/qtum/gas_test.go

@@ -0,0 +1,54 @@
+package qtum_test
+
+// Shamelessly stolen from Dogecoin's re-export of bitcoin's implementation. Steal-ception!
+
+import (
+	"context"
+
+	"github.com/renproject/multichain/chain/qtum"
+	"github.com/renproject/pack"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Gas", func() {
+	Context("when estimating qtum network fee", func() {
+		It("should work", func() {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+
+			client := qtum.NewClient(qtum.DefaultClientOptions())
+
+			// estimate fee to include tx within 1 block.
+			fallback1 := uint64(123)
+			gasEstimator1 := qtum.NewGasEstimator(client, 1, pack.NewU256FromUint64(fallback1))
+			gasPrice1, _, err := gasEstimator1.EstimateGas(ctx)
+			if err != nil {
+				Expect(gasPrice1).To(Equal(pack.NewU256FromUint64(fallback1)))
+			}
+
+			// estimate fee to include tx within 10 blocks.
+			fallback2 := uint64(234)
+			gasEstimator2 := qtum.NewGasEstimator(client, 10, pack.NewU256FromUint64(fallback2))
+			gasPrice2, _, err := gasEstimator2.EstimateGas(ctx)
+			if err != nil {
+				Expect(gasPrice2).To(Equal(pack.NewU256FromUint64(fallback2)))
+			}
+
+			// estimate fee to include tx within 100 blocks.
+			fallback3 := uint64(345)
+			gasEstimator3 := qtum.NewGasEstimator(client, 100, pack.NewU256FromUint64(fallback3))
+			gasPrice3, _, err := gasEstimator3.EstimateGas(ctx)
+			if err != nil {
+				Expect(gasPrice3).To(Equal(pack.NewU256FromUint64(fallback3)))
+			}
+
+			// expect fees in this order at the very least.
+			if err == nil {
+				Expect(gasPrice1.GreaterThanEqual(gasPrice2)).To(BeTrue())
+				Expect(gasPrice2.GreaterThanEqual(gasPrice3)).To(BeTrue())
+			}
+		})
+	})
+})