Merge pull request #39 from renproject/feat/bitcoin-fee-estimation

bitcoin fee estimation

Author: jazg

Diff for: chain/bitcoin/bitcoin.go

@@ -88,6 +88,8 @@ type Client interface {
 	UnspentOutputs(ctx context.Context, minConf, maxConf int64, address address.Address) ([]utxo.Output, error)
 	// Confirmations of a transaction in the Bitcoin network.
 	Confirmations(ctx context.Context, txHash pack.Bytes) (int64, error)
+	// EstimateSmartFee
+	EstimateSmartFee(ctx context.Context, numBlocks int64) (float64, error)
 }
 
 type client struct {
@@ -239,6 +241,24 @@ func (client *client) Confirmations(ctx context.Context, txHash pack.Bytes) (int
 	return confirmations, nil
 }
 
+// EstimateSmartFee fetches the estimated bitcoin network fees to be paid (in
+// BTC per kilobyte) needed for a transaction to be confirmed within `numBlocks`
+// blocks. An error will be returned if the bitcoin node hasn't observed enough
+// blocks to make an estimate for the provided target `numBlocks`.
+func (client *client) EstimateSmartFee(ctx context.Context, numBlocks int64) (float64, error) {
+	resp := btcjson.EstimateSmartFeeResult{}
+
+	if err := client.send(ctx, &resp, "estimatesmartfee", numBlocks); err != nil {
+		return 0.0, fmt.Errorf("estimating smart fee: %v", err)
+	}
+
+	if resp.Errors != nil && len(resp.Errors) > 0 {
+		return 0.0, fmt.Errorf("estimating smart fee: %v", resp.Errors[0])
+	}
+
+	return *resp.FeeRate, nil
+}
+
 func (client *client) send(ctx context.Context, resp interface{}, method string, params ...interface{}) error {
 	// Encode the request.
 	data, err := encodeRequest(method, params)

Diff for: chain/bitcoin/gas.go

@@ -6,27 +6,44 @@ import (
 	"github.com/renproject/pack"
 )
 
+const (
+	btcToSatoshis  = 1e8
+	kilobyteToByte = 1024
+)
+
 // A GasEstimator returns the SATs-per-byte that is needed in order to confirm
 // transactions with an estimated maximum delay of one block. In distributed
 // networks that collectively build, sign, and submit transactions, it is
 // important that all nodes in the network have reached consensus on the
 // SATs-per-byte.
 type GasEstimator struct {
-	satsPerByte pack.U256
+	client    Client
+	numBlocks int64
 }
 
 // NewGasEstimator returns a simple gas estimator that always returns the given
 // number of SATs-per-byte.
-func NewGasEstimator(satsPerByte pack.U256) GasEstimator {
+func NewGasEstimator(client Client, numBlocks int64) GasEstimator {
 	return GasEstimator{
-		satsPerByte: satsPerByte,
+		client:    client,
+		numBlocks: numBlocks,
 	}
 }
 
 // EstimateGasPrice returns the number of SATs-per-byte that is needed in order
-// to confirm transactions with an estimated maximum delay of one block. It is
-// the responsibility of the caller to know the number of bytes in their
-// transaction.
-func (gasEstimator GasEstimator) EstimateGasPrice(_ context.Context) (pack.U256, pack.U256, error) {
-	return gasEstimator.satsPerByte, pack.NewU256([32]byte{}), nil
+// to confirm transactions with an estimated maximum delay of `numBlocks` block.
+// It is the responsibility of the caller to know the number of bytes in their
+// transaction. This method calls the `estimatesmartfee` RPC call to the node,
+// which based on a conservative (considering longer history) strategy returns
+// the estimated BTC per kilobyte of data in the transaction. An error will be
+// returned if the bitcoin node hasn't observed enough blocks to make an
+// estimate for the provided target `numBlocks`.
+func (gasEstimator GasEstimator) EstimateGasPrice(ctx context.Context) (pack.U256, pack.U256, error) {
+	feeRate, err := gasEstimator.client.EstimateSmartFee(ctx, gasEstimator.numBlocks)
+	if err != nil {
+		return pack.NewU256([32]byte{}), pack.NewU256([32]byte{}), err
+	}
+
+	satsPerByte := uint64(feeRate * btcToSatoshis / kilobyteToByte)
+	return pack.NewU256FromU64(pack.NewU64(satsPerByte)), pack.NewU256([32]byte{}), nil
 }

Diff for: chain/bitcoin/gas_test.go

@@ -1 +1,40 @@
 package bitcoin_test
+
+import (
+	"context"
+
+	"github.com/renproject/multichain/chain/bitcoin"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Gas", func() {
+	Context("when estimating bitcoin network fee", func() {
+		It("should work", func() {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+
+			client := bitcoin.NewClient(bitcoin.DefaultClientOptions())
+
+			// estimate fee to include tx within 1 block.
+			gasEstimator1 := bitcoin.NewGasEstimator(client, 1)
+			gasPrice1, _, err := gasEstimator1.EstimateGasPrice(ctx)
+			Expect(err).NotTo(HaveOccurred())
+
+			// estimate fee to include tx within 10 blocks.
+			gasEstimator2 := bitcoin.NewGasEstimator(client, 10)
+			gasPrice2, _, err := gasEstimator2.EstimateGasPrice(ctx)
+			Expect(err).NotTo(HaveOccurred())
+
+			// estimate fee to include tx within 100 blocks.
+			gasEstimator3 := bitcoin.NewGasEstimator(client, 100)
+			gasPrice3, _, err := gasEstimator3.EstimateGasPrice(ctx)
+			Expect(err).NotTo(HaveOccurred())
+
+			// expect fees in this order at the very least.
+			Expect(gasPrice1.GreaterThanEqual(gasPrice2)).To(BeTrue())
+			Expect(gasPrice2.GreaterThanEqual(gasPrice3)).To(BeTrue())
+		})
+	})
+})

Diff for: infra/bitcoin/run.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
 ADDRESS=$1
+PRIV_KEY=$2
 
 # Start
 /app/bin/bitcoind
@@ -11,12 +12,19 @@ echo "BITCOIN_ADDRESS=$ADDRESS"
 # Import the address
 /app/bin/bitcoin-cli importaddress $ADDRESS
 
+# Import the private key to spend UTXOs
+/app/bin/bitcoin-cli importprivkey $PRIV_KEY
+
 # Generate enough block to pass the maturation time
 /app/bin/bitcoin-cli generatetoaddress 101 $ADDRESS
 
 # Simulate mining
 while :
 do
+    # generate new btc to the address
     /app/bin/bitcoin-cli generatetoaddress 1 $ADDRESS
-    sleep 10
-done
+    sleep 5
+    # send tx to own address while paying fee to the miner
+    /app/bin/bitcoin-cli sendtoaddress $ADDRESS 0.5 "" "" true
+    sleep 5
+done

Diff for: infra/docker-compose.yaml

@@ -37,6 +37,7 @@ services:
     entrypoint:
       - "./root/run.sh"
       - "${BITCOIN_ADDRESS}"
+      - "${BITCOIN_PK}"
 
   #
   # Bitcoin Cash