Merge branch 'next-version' into vtxo-commitment-txids

Author: altafan

common/encoding.go

@@ -8,24 +8,25 @@ import (
 	"github.com/decred/dcrd/dcrec/secp256k1/v4"
 )
 
-// Address represents an Ark address with HRP, server public key, and VTXO Taproot public key
+// Address represents an Ark address with Vvrsion, prefix, server public key, and VTXO taproot key.
 type Address struct {
+	Version    uint8
 	HRP        string
 	Server     *secp256k1.PublicKey
 	VtxoTapKey *secp256k1.PublicKey
 }
 
-// Encode converts the address to its bech32m string representation
-func (a *Address) Encode() (string, error) {
+// EncodeV0 converts the address to its bech32m string representation.
+func (a *Address) EncodeV0() (string, error) {
 	if a.Server == nil {
 		return "", fmt.Errorf("missing server public key")
 	}
 	if a.VtxoTapKey == nil {
-		return "", fmt.Errorf("missing vtxo tap public key")
+		return "", fmt.Errorf("missing vtxo taproot key")
 	}
 
 	combinedKey := append(
-		schnorr.SerializePubKey(a.Server), schnorr.SerializePubKey(a.VtxoTapKey)...,
+		[]byte{byte(a.Version)}, append(schnorr.SerializePubKey(a.Server), schnorr.SerializePubKey(a.VtxoTapKey)...)...,
 	)
 	grp, err := bech32.ConvertBits(combinedKey, 8, 5, true)
 	if err != nil {
@@ -34,35 +35,46 @@ func (a *Address) Encode() (string, error) {
 	return bech32.EncodeM(a.HRP, grp)
 }
 
-// DecodeAddress parses a bech32m encoded address string and returns an Address object
-func DecodeAddress(addr string) (*Address, error) {
+// DecodeAddressV0 parses a bech32m encoded address string and returns an Address struct.
+func DecodeAddressV0(addr string) (*Address, error) {
 	if len(addr) == 0 {
-		return nil, fmt.Errorf("address is empty")
+		return nil, fmt.Errorf("mssing address")
 	}
 
 	prefix, buf, err := bech32.DecodeNoLimit(addr)
 	if err != nil {
 		return nil, err
 	}
 	if prefix != Bitcoin.Addr && prefix != BitcoinTestNet.Addr && prefix != BitcoinRegTest.Addr {
-		return nil, fmt.Errorf("invalid prefix")
+		return nil, fmt.Errorf("unknown prefix")
 	}
 	grp, err := bech32.ConvertBits(buf, 5, 8, false)
 	if err != nil {
 		return nil, err
 	}
 
-	serverKey, err := schnorr.ParsePubKey(grp[:32])
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse public key: %s", err)
+	// [version, serverKey, vtxoKey]
+	if len(grp) != 1+32+32 {
+		return nil, fmt.Errorf("invalid address bytes length, expected 65 got %d", len(grp))
+	}
+
+	version := uint8(grp[0])
+	if version != 0 {
+		return nil, fmt.Errorf("invalid address version, expected 0 got %d", version)
 	}
 
-	vtxoKey, err := schnorr.ParsePubKey(grp[32:])
+	serverKey, err := schnorr.ParsePubKey(grp[1:33])
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse server public key: %s", err)
 	}
 
+	vtxoKey, err := schnorr.ParsePubKey(grp[33:])
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse vtxo taproot key: %s", err)
+	}
+
 	return &Address{
+		Version:    version,
 		HRP:        prefix,
 		Server:     serverKey,
 		VtxoTapKey: vtxoKey,

common/encoding_test.go

@@ -26,6 +26,8 @@ func TestAddressEncoding(t *testing.T) {
 		Address struct {
 			Valid []struct {
 				Addr              string `json:"addr"`
+				ExpectedVersion   uint8  `json:"expectedVersion"`
+				ExpectedPrefix    string `json:"expectedPrefix"`
 				ExpectedUserKey   string `json:"expectedUserKey"`
 				ExpectedServerKey string `json:"expectedServerKey"`
 			} `json:"valid"`
@@ -40,29 +42,27 @@ func TestAddressEncoding(t *testing.T) {
 
 	t.Run("valid", func(t *testing.T) {
 		for _, f := range fixtures.Address.Valid {
-			addr, err := common.DecodeAddress(f.Addr)
-			require.NoError(t, err)
-			require.NotEmpty(t, addr.HRP)
-			require.NotNil(t, addr.Server)
-			require.NotNil(t, addr.VtxoTapKey)
-
+			addr, err := common.DecodeAddressV0(f.Addr)
 			require.NoError(t, err)
+			require.NotNil(t, addr)
+			require.Equal(t, f.ExpectedVersion, addr.Version)
+			require.Equal(t, f.ExpectedPrefix, addr.HRP)
 			require.Equal(t, f.ExpectedUserKey, hex.EncodeToString(addr.VtxoTapKey.SerializeCompressed()))
-
-			require.NoError(t, err)
 			require.Equal(t, f.ExpectedServerKey, hex.EncodeToString(addr.Server.SerializeCompressed()))
 
-			encoded, err := addr.Encode()
+			encoded, err := addr.EncodeV0()
 			require.NoError(t, err)
 			require.Equal(t, f.Addr, encoded)
 		}
 	})
 
 	t.Run("invalid", func(t *testing.T) {
 		for _, f := range fixtures.Address.Invalid {
-			addr, err := common.DecodeAddress(f.Addr)
-			require.EqualError(t, err, f.ExpectedError)
-			require.Nil(t, addr)
+			t.Run(f.ExpectedError, func(t *testing.T) {
+				addr, err := common.DecodeAddressV0(f.Addr)
+				require.Contains(t, err.Error(), f.ExpectedError)
+				require.Nil(t, addr)
+			})
 		}
 	})
 }

common/fixtures/encoding.json

@@ -2,15 +2,21 @@
   "address": {
     "valid": [
       {
-        "addr": "tark1x0lm8hhr2wc6n6lyemtyh9rz8rg2ftpkfun46aca56kjg3ws0tsztfpuanaquxc6faedvjk3tax0575y6perapg3e95654pk8r4fjecs5fyd2",
+        "addr": "tark1qqellv77udfmr20tun8dvju5vgudpf9vxe8jwhthrkn26fz96pawqfdy8nk05rsmrf8h94j26905e7n6sng8y059z8ykn2j5xcuw4xt846qj6x",
+        "expectedVersion": 0,
+        "expectedPrefix": "tark",
         "expectedUserKey": "0225a43cecfa0e1b1a4f72d64ad15f4cfa7a84d0723e8511c969aa543638ea9967",
         "expectedServerKey": "0233ffb3dee353b1a9ebe4ced64b946238d0a4ac364f275d771da6ad2445d07ae0"
       }
     ],
     "invalid": [
       {
         "addr": "wrongprefix1qt9tfh7c09hlsstzq5y9tzuwyaesrwr8gpy8cn29cxv0flp64958s0n0yd0",
-        "expectedError": "invalid prefix"
+        "expectedError": "unknown prefix"
+      },
+      {
+        "addr": "tark1x0lm8hhr2wc6n6lyemtyh9rz8rg2ftpkfun46aca56kjg3ws0tsztfpuanaquxc6faedvjk3tax0575y6perapg3e95654pk8r4fjecs5fyd2",
+        "expectedError": "invalid address bytes length"
       }
     ]
   }

pkg/client-sdk/base_client.go

@@ -18,7 +18,6 @@ import (
 	walletstore "github.com/ark-network/ark/pkg/client-sdk/wallet/singlekey/store"
 	filestore "github.com/ark-network/ark/pkg/client-sdk/wallet/singlekey/store/file"
 	inmemorystore "github.com/ark-network/ark/pkg/client-sdk/wallet/singlekey/store/inmemory"
-	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/decred/dcrd/dcrec/secp256k1/v4"
 )
 
@@ -199,14 +198,16 @@ func (a *arkClient) NotifyIncomingFunds(
 		return nil, fmt.Errorf("wallet not initialized")
 	}
 
-	decoded, err := common.DecodeAddress(addr)
+	decoded, err := common.DecodeAddressV0(addr)
 	if err != nil {
 		return nil, err
 	}
-
-	scripts := []string{
-		hex.EncodeToString(schnorr.SerializePubKey(decoded.VtxoTapKey)),
+	script, err := common.P2TRScript(decoded.VtxoTapKey)
+	if err != nil {
+		return nil, err
 	}
+
+	scripts := []string{hex.EncodeToString(script)}
 	subId, err := a.indexer.SubscribeForScripts(ctx, "", scripts)
 	if err != nil {
 		return nil, err

pkg/client-sdk/client.go

@@ -506,7 +506,7 @@ func (a *covenantlessArkClient) SendOffChain(
 			return "", fmt.Errorf("all receiver addresses must be offchain addresses")
 		}
 
-		addr, err := common.DecodeAddress(receiver.To)
+		addr, err := common.DecodeAddressV0(receiver.To)
 		if err != nil {
 			return "", fmt.Errorf("invalid receiver address: %s", err)
 		}
@@ -1070,23 +1070,24 @@ func (a *covenantlessArkClient) listenForArkTxs(ctx context.Context) {
 				continue
 			}
 
-			myPubkeys := make(map[string]struct{})
+			myScripts := make(map[string]struct{})
 			for _, addr := range offchainAddrs {
-				// nolint:all
-				decoded, _ := common.DecodeAddress(addr.Address)
-				pubkey := hex.EncodeToString(decoded.VtxoTapKey.SerializeCompressed()[1:])
-				myPubkeys[pubkey] = struct{}{}
+				// nolint
+				decoded, _ := common.DecodeAddressV0(addr.Address)
+				// nolint
+				script, _ := common.P2TRScript(decoded.VtxoTapKey)
+				myScripts[hex.EncodeToString(script)] = struct{}{}
 			}
 
 			if event.CommitmentTx != nil {
-				if err := a.handleCommitmentTx(ctxBg, myPubkeys, event.CommitmentTx); err != nil {
+				if err := a.handleCommitmentTx(ctxBg, myScripts, event.CommitmentTx); err != nil {
 					log.WithError(err).Error("failed to process commitment tx")
 					continue
 				}
 			}
 
 			if event.ArkTx != nil {
-				if err := a.handleArkTx(ctxBg, myPubkeys, event.ArkTx); err != nil {
+				if err := a.handleArkTx(ctxBg, myScripts, event.ArkTx); err != nil {
 					log.WithError(err).Error("failed to process ark tx")
 					continue
 				}
@@ -1626,7 +1627,7 @@ func (a *covenantlessArkClient) sendOffchain(
 
 	// validate receivers and create outputs
 	for _, receiver := range receivers {
-		rcvAddr, err := common.DecodeAddress(receiver.To)
+		rcvAddr, err := common.DecodeAddressV0(receiver.To)
 		if err != nil {
 			return "", fmt.Errorf("invalid receiver address: %s", err)
 		}
@@ -1980,7 +1981,7 @@ func (a *covenantlessArkClient) handleBatchEvents(
 	step := start
 	hasOffchainOutput := false
 	for _, receiver := range receivers {
-		if _, err := common.DecodeAddress(receiver.To); err == nil {
+		if _, err := common.DecodeAddressV0(receiver.To); err == nil {
 			hasOffchainOutput = true
 			break
 		}
@@ -2513,7 +2514,7 @@ func (a *covenantlessArkClient) validateOffchainReceiver(
 ) error {
 	found := false
 
-	rcvAddr, err := common.DecodeAddress(receiver.To)
+	rcvAddr, err := common.DecodeAddressV0(receiver.To)
 	if err != nil {
 		return err
 	}

pkg/client-sdk/types/types.go

@@ -73,10 +73,11 @@ func (v Vtxo) IsRecoverable() bool {
 }
 
 func (v Vtxo) Address(server *secp256k1.PublicKey, net common.Network) (string, error) {
-	pubkeyBytes, err := hex.DecodeString(v.Script)
+	buf, err := hex.DecodeString(v.Script)
 	if err != nil {
 		return "", err
 	}
+	pubkeyBytes := buf[2:]
 
 	pubkey, err := schnorr.ParsePubKey(pubkeyBytes)
 	if err != nil {
@@ -89,7 +90,7 @@ func (v Vtxo) Address(server *secp256k1.PublicKey, net common.Network) (string,
 		VtxoTapKey: pubkey,
 	}
 
-	return a.Encode()
+	return a.EncodeV0()
 }
 
 type VtxoEventType int
@@ -198,7 +199,7 @@ func (o Receiver) ToTxOut() (*wire.TxOut, bool, error) {
 	var pkScript []byte
 	isOnchain := false
 
-	arkAddress, err := common.DecodeAddress(o.To)
+	arkAddress, err := common.DecodeAddressV0(o.To)
 	if err != nil {
 		// decode onchain address
 		btcAddress, err := btcutil.DecodeAddress(o.To, nil)

pkg/client-sdk/utils.go

@@ -96,7 +96,7 @@ func buildOffchainTx(
 			return "", nil, fmt.Errorf("receiver %d is onchain", i)
 		}
 
-		addr, err := common.DecodeAddress(receiver.To)
+		addr, err := common.DecodeAddressV0(receiver.To)
 		if err != nil {
 			return "", nil, err
 		}

pkg/client-sdk/wallet/singlekey/bitcoin_wallet.go

@@ -51,7 +51,7 @@ func (w *bitcoinWallet) GetAddresses(
 		return nil, nil, nil, nil, err
 	}
 
-	encodedOffchainAddr, err := offchainAddr.Address.Encode()
+	encodedOffchainAddr, err := offchainAddr.Address.EncodeV0()
 	if err != nil {
 		return nil, nil, nil, nil, err
 	}
@@ -106,7 +106,7 @@ func (w *bitcoinWallet) NewAddress(
 		return "", nil, nil, err
 	}
 
-	encodedOffchainAddr, err := offchainAddr.Address.Encode()
+	encodedOffchainAddr, err := offchainAddr.Address.EncodeV0()
 	if err != nil {
 		return "", nil, nil, err
 	}
@@ -133,7 +133,7 @@ func (w *bitcoinWallet) NewAddresses(
 	offchainAddrs := make([]wallet.TapscriptsAddress, 0, num)
 	boardingAddrs := make([]wallet.TapscriptsAddress, 0, num)
 	for i := 0; i < num; i++ {
-		encodedOffchainAddr, err := offchainAddr.Address.Encode()
+		encodedOffchainAddr, err := offchainAddr.Address.EncodeV0()
 		if err != nil {
 			return nil, nil, nil, err
 		}

server/internal/core/application/service.go

@@ -1234,7 +1234,7 @@ func (s *covenantlessService) SignRoundTx(ctx context.Context, signedRoundTx str
 }
 
 func (s *covenantlessService) ListVtxos(ctx context.Context, address string) ([]domain.Vtxo, []domain.Vtxo, error) {
-	decodedAddress, err := common.DecodeAddress(address)
+	decodedAddress, err := common.DecodeAddressV0(address)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to decode address: %s", err)
 	}
@@ -1366,7 +1366,7 @@ func (s *covenantlessService) GetTxRequestQueue(
 				VtxoTapKey: vtxoTapKey,
 			}
 
-			addressStr, err := address.Encode()
+			addressStr, err := address.EncodeV0()
 			if err != nil {
 				return nil, fmt.Errorf("failed to encode address: %s", err)
 			}