add "block" scheduler type + sweep integration test

common/bip68.go

@@ -1,8 +1,10 @@
 package common
 
 import (
-	"encoding/hex"
 	"fmt"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/txscript"
 )
 
 const (
@@ -18,48 +20,40 @@ func closerToModulo512(x uint) uint {
 	return x - (x % 512)
 }
 
-func BIP68EncodeAsNumber(seconds uint) (uint32, error) {
-	seconds = closerToModulo512(seconds)
-	if seconds > SECONDS_MAX {
-		return 0, fmt.Errorf("seconds too large, max is %d", SECONDS_MAX)
-	}
-	if seconds%SECONDS_MOD != 0 {
-		return 0, fmt.Errorf("seconds must be a multiple of %d", SECONDS_MOD)
+func BIP68Sequence(locktime uint) (uint32, error) {
+	isSeconds := locktime >= 512
+	if isSeconds {
+		locktime = closerToModulo512(locktime)
+		if locktime > SECONDS_MAX {
+			return 0, fmt.Errorf("seconds too large, max is %d", SECONDS_MAX)
+		}
+		if locktime%SECONDS_MOD != 0 {
+			return 0, fmt.Errorf("seconds must be a multiple of %d", SECONDS_MOD)
+		}
 	}
 
-	asNumber := SEQUENCE_LOCKTIME_TYPE_FLAG | (seconds >> SEQUENCE_LOCKTIME_GRANULARITY)
-	return uint32(asNumber), nil
+	return blockchain.LockTimeToSequence(isSeconds, uint32(locktime)), nil
 }
 
-// BIP68Encode returns the encoded sequence locktime for the given number of seconds.
-func BIP68Encode(seconds uint) ([]byte, error) {
-	asNumber, err := BIP68EncodeAsNumber(seconds)
-	if err != nil {
-		return nil, err
-	}
-	hexString := fmt.Sprintf("%x", asNumber)
-	reversed, err := hex.DecodeString(hexString)
+func BIP68DecodeSequence(sequence []byte) (uint, error) {
+	scriptNumber, err := txscript.MakeScriptNum(sequence, true, len(sequence))
 	if err != nil {
-		return nil, err
+		return 0, err
 	}
-	for i, j := 0, len(reversed)-1; i < j; i, j = i+1, j-1 {
-		reversed[i], reversed[j] = reversed[j], reversed[i]
-	}
-	return reversed, nil
-}
 
-func BIP68Decode(sequence []byte) (uint, error) {
-	var asNumber int64
-	for i := len(sequence) - 1; i >= 0; i-- {
-		asNumber = asNumber<<8 | int64(sequence[i])
+	if scriptNumber >= txscript.OP_1 && scriptNumber <= txscript.OP_16 {
+		scriptNumber = scriptNumber - (txscript.OP_1 - 1)
 	}
 
+	asNumber := int64(scriptNumber)
+
 	if asNumber&SEQUENCE_LOCKTIME_DISABLE_FLAG != 0 {
 		return 0, fmt.Errorf("sequence is disabled")
 	}
 	if asNumber&SEQUENCE_LOCKTIME_TYPE_FLAG != 0 {
 		seconds := asNumber & SEQUENCE_LOCKTIME_MASK << SEQUENCE_LOCKTIME_GRANULARITY
 		return uint(seconds), nil
 	}
-	return 0, fmt.Errorf("sequence is encoded as block number")
+
+	return uint(asNumber), nil
 }

common/bitcointree/script.go

@@ -109,9 +109,12 @@ func (d *CSVSigClosure) Decode(script []byte) (bool, error) {
 		return false, nil
 	}
 
-	sequence := script[1:csvIndex]
+	sequence := script[:csvIndex]
+	if len(sequence) > 1 {
+		sequence = sequence[1:]
+	}
 
-	seconds, err := common.BIP68Decode(sequence)
+	seconds, err := common.BIP68DecodeSequence(sequence)
 	if err != nil {
 		return false, err
 	}
@@ -162,15 +165,18 @@ func decodeChecksigScript(script []byte) (bool, *secp256k1.PublicKey, error) {
 
 // checkSequenceVerifyScript without checksig
 func encodeCsvScript(seconds uint) ([]byte, error) {
-	sequence, err := common.BIP68Encode(seconds)
+	sequence, err := common.BIP68Sequence(seconds)
 	if err != nil {
 		return nil, err
 	}
 
-	return txscript.NewScriptBuilder().AddData(sequence).AddOps([]byte{
-		txscript.OP_CHECKSEQUENCEVERIFY,
-		txscript.OP_DROP,
-	}).Script()
+	return txscript.NewScriptBuilder().
+		AddInt64(int64(sequence)).
+		AddOps([]byte{
+			txscript.OP_CHECKSEQUENCEVERIFY,
+			txscript.OP_DROP,
+		}).
+		Script()
 }
 
 // checkSequenceVerifyScript + checksig

common/bitcointree/script_test.go

@@ -0,0 +1,30 @@
+package bitcointree_test
+
+import (
+	"testing"
+
+	"github.com/ark-network/ark/common/bitcointree"
+	"github.com/decred/dcrd/dcrec/secp256k1/v4"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRoundTripCSV(t *testing.T) {
+	seckey, err := secp256k1.GeneratePrivateKey()
+	require.NoError(t, err)
+
+	csvSig := &bitcointree.CSVSigClosure{
+		Pubkey:  seckey.PubKey(),
+		Seconds: 1024,
+	}
+
+	leaf, err := csvSig.Leaf()
+	require.NoError(t, err)
+
+	var cl bitcointree.CSVSigClosure
+
+	valid, err := cl.Decode(leaf.Script)
+	require.NoError(t, err)
+	require.True(t, valid)
+
+	require.Equal(t, csvSig.Seconds, cl.Seconds)
+}

common/descriptor/expression.go

@@ -130,15 +130,18 @@ func (e *Older) Parse(policy string) error {
 }
 
 func (e *Older) Script(bool) (string, error) {
-	sequence, err := common.BIP68Encode(e.Timeout)
+	sequence, err := common.BIP68Sequence(e.Timeout)
 	if err != nil {
 		return "", err
 	}
 
-	script, err := txscript.NewScriptBuilder().AddData(sequence).AddOps([]byte{
-		txscript.OP_CHECKSEQUENCEVERIFY,
-		txscript.OP_DROP,
-	}).Script()
+	script, err := txscript.NewScriptBuilder().
+		AddInt64(int64(sequence)).
+		AddOps([]byte{
+			txscript.OP_CHECKSEQUENCEVERIFY,
+			txscript.OP_DROP,
+		}).
+		Script()
 	if err != nil {
 		return "", err
 	}

common/tree/script.go

@@ -130,9 +130,12 @@ func (d *CSVSigClosure) Decode(script []byte) (bool, error) {
 		return false, nil
 	}
 
-	sequence := script[1:csvIndex]
+	sequence := script[:csvIndex]
+	if len(sequence) > 1 {
+		sequence = sequence[1:]
+	}
 
-	seconds, err := common.BIP68Decode(sequence)
+	seconds, err := common.BIP68DecodeSequence(sequence)
 	if err != nil {
 		return false, err
 	}
@@ -369,15 +372,18 @@ func decodeChecksigScript(script []byte) (bool, *secp256k1.PublicKey, error) {
 
 // checkSequenceVerifyScript without checksig
 func encodeCsvScript(seconds uint) ([]byte, error) {
-	sequence, err := common.BIP68Encode(seconds)
+	sequence, err := common.BIP68Sequence(seconds)
 	if err != nil {
 		return nil, err
 	}
 
-	return txscript.NewScriptBuilder().AddData(sequence).AddOps([]byte{
-		txscript.OP_CHECKSEQUENCEVERIFY,
-		txscript.OP_DROP,
-	}).Script()
+	return txscript.NewScriptBuilder().
+		AddInt64(int64(sequence)).
+		AddOps([]byte{
+			txscript.OP_CHECKSEQUENCEVERIFY,
+			txscript.OP_DROP,
+		}).
+		Script()
 }
 
 // checkSequenceVerifyScript + checksig

docker-compose.clark.regtest.yml

@@ -9,12 +9,13 @@ services:
       - ARK_ROUND_INTERVAL=10
       - ARK_NETWORK=regtest
       - ARK_LOG_LEVEL=5
-      - ARK_ROUND_LIFETIME=512
+      - ARK_ROUND_LIFETIME=20
       - ARK_TX_BUILDER_TYPE=covenantless
       - ARK_ESPLORA_URL=http://chopsticks:3000
       - ARK_BITCOIND_RPC_USER=admin1
       - ARK_BITCOIND_RPC_PASS=123
       - ARK_BITCOIND_RPC_HOST=bitcoin:18443
+      - ARK_SCHEDULER_TYPE=block
       - ARK_NO_TLS=true
       - ARK_NO_MACAROONS=true
       - ARK_DATADIR=/app/data

docker-compose.regtest.yml

@@ -31,7 +31,9 @@ services:
       - ARK_ROUND_INTERVAL=10
       - ARK_NETWORK=liquidregtest
       - ARK_LOG_LEVEL=5
-      - ARK_ROUND_LIFETIME=512
+      - ARK_ESPLORA_URL=http://chopsticks-liquid:3000
+      - ARK_ROUND_LIFETIME=20
+      - ARK_SCHEDULER_TYPE=block
       - ARK_DB_TYPE=sqlite
       - ARK_TX_BUILDER_TYPE=covenant
       - ARK_PORT=6060

pkg/client-sdk/explorer/explorer.go

@@ -35,7 +35,7 @@ type Utxo struct {
 }
 
 func (u *Utxo) Sequence() (uint32, error) {
-	return common.BIP68EncodeAsNumber(u.Delay)
+	return common.BIP68Sequence(u.Delay)
 }
 
 func newUtxo(explorerUtxo ExplorerUtxo, delay uint) Utxo {

server/Makefile

@@ -23,8 +23,8 @@ help:
 ## intergrationtest: runs integration tests
 integrationtest:
 	@echo "Running integration tests..."
-	@go test -v -count 1 -timeout 300s github.com/ark-network/ark/server/test/e2e/covenant
-	@go test -v -count 1 -timeout 300s github.com/ark-network/ark/server/test/e2e/covenantless
+	@go test -v -count 1 -timeout 400s github.com/ark-network/ark/server/test/e2e/covenant
+	@go test -v -count 1 -timeout 400s github.com/ark-network/ark/server/test/e2e/covenantless
 
 ## lint: lint codebase
 lint: