Bitcoin address refactor

app/app.go

@@ -156,7 +156,6 @@ import (
 
 	// this line is used by starport scaffolding # stargate/app/moduleImport
 	btccodec "github.com/sideprotocol/side/bitcoin/crypto/codec"
-	bitcoinkeys "github.com/sideprotocol/side/bitcoin/keys"
 )
 
 const (
@@ -339,7 +338,7 @@ func New(
 		SigningOptions: signing.Options{
 			AddressCodec: btcbridgecodec.NewBech32Codec(
 				sdk.GetConfig().GetBech32AccountAddrPrefix(),
-				bitcoinkeys.Network.Bech32HRPSegwit,
+				bitcoin.Network.Bech32HRPSegwit,
 			),
 			ValidatorAddressCodec: address.Bech32Codec{
 				Bech32Prefix: sdk.GetConfig().GetBech32ValidatorAddrPrefix(),
@@ -445,7 +444,7 @@ func New(
 		maccPerms,
 		btcbridgecodec.NewBech32Codec(
 			sdk.GetConfig().GetBech32AccountAddrPrefix(),
-			bitcoinkeys.Network.Bech32HRPSegwit,
+			bitcoin.Network.Bech32HRPSegwit,
 		),
 		sdk.GetConfig().GetBech32AccountAddrPrefix(),
 		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
@@ -1142,7 +1141,7 @@ func (app *App) AutoCliOpts() autocli.AppOptions {
 		ModuleOptions: runtimeservices.ExtractAutoCLIOptions(app.ModuleManager.Modules),
 		AddressCodec: btcbridgecodec.NewBech32Codec(
 			sdk.GetConfig().GetBech32AccountAddrPrefix(),
-			bitcoinkeys.Network.Bech32HRPSegwit,
+			bitcoin.Network.Bech32HRPSegwit,
 		),
 		ValidatorAddressCodec: authcodec.NewBech32Codec(sdk.GetConfig().GetBech32ValidatorAddrPrefix()),
 		ConsensusAddressCodec: authcodec.NewBech32Codec(sdk.GetConfig().GetBech32ConsensusAddrPrefix()),

app/config.go

@@ -4,7 +4,7 @@ import (
 	"github.com/cosmos/btcutil/bech32"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	"github.com/sideprotocol/side/bitcoin/keys"
+	"github.com/sideprotocol/side/bitcoin"
 )
 
 func init() {
@@ -23,6 +23,6 @@ func init() {
 	// config.SetBtcChainCfg(&chaincfg.TestNet3Params)
 	config.Seal()
 
-	bech32.BITCOIN_HRP = keys.Network.Bech32HRPSegwit
+	bech32.BITCOIN_HRP = bitcoin.Network.Bech32HRPSegwit
 	bech32.SIDE_HRP = AccountAddressPrefix
 }

bitcoin/address_test.go

@@ -5,9 +5,9 @@ import (
 	"testing"
 
 	"github.com/btcsuite/btcd/btcutil"
-	"github.com/btcsuite/btcd/btcutil/bech32"
 	"github.com/btcsuite/btcd/chaincfg"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/sideprotocol/side/bitcoin"
 	"github.com/sideprotocol/side/bitcoin/keys/segwit"
 	"github.com/sideprotocol/side/bitcoin/keys/taproot"
 	"github.com/stretchr/testify/assert"
@@ -37,7 +37,7 @@ func TestAddressEncodeDecode(t *testing.T) {
 		} else if strings.HasPrefix(a, "bc1q") {
 			assert.Equal(t, 33, len(addr.Bytes()), a)
 		} else {
-			assert.Equal(t, 53, len(addr.Bytes()), a)
+			assert.Equal(t, 32, len(addr.Bytes()), a)
 		}
 
 		text_addr := addr.String()
@@ -52,42 +52,60 @@ func TestGenKeys(t *testing.T) {
 	conf := sdk.GetConfig()
 	conf.SetBech32PrefixForAccount("side", "side")
 	conf.Seal()
+	bitcoin.Network = &chaincfg.MainNetParams
 
 	// hash := btcutil.Hash160([]byte{0, 3, 3, 3, 3, 3})
 	hash := make([]byte, 32, 32)
 	assert.Equal(t, 32, len(hash))
 
 	// sh, err := btcutil.NewAddressScriptHashFromHash(hash, &chaincfg.MainNetParams)
 	// assert.NoError(t, err)
-	std, err := btcutil.NewAddressTaproot(hash, &chaincfg.MainNetParams)
+	std, err := btcutil.NewAddressTaproot(hash, bitcoin.Network)
 	assert.NoError(t, err)
 	assert.Equal(t, 32, len(std.AddressSegWit.ScriptAddress()))
 	// println(std.ScriptAddress())
-	text := std.AddressSegWit.EncodeAddress()
-	_, bte, err := bech32.Decode(text)
-	assert.NoError(t, err)
-	assert.Equal(t, 53, len(bte), text)
-	a_str := sdk.MustAccAddressFromBech32(text)
-	assert.Equal(t, 53, len(a_str.Bytes()), text)
-	assert.Equal(t, bte, a_str.Bytes())
-
-	addrs := []sdk.Address{sdk.AccAddress(taproot.GenPrivKey().PubKey().Address()), sdk.AccAddress(segwit.GenPrivKey().PubKey().Address())}
-
-	for _, a := range addrs {
-		assert.Equal(t, true, strings.HasPrefix(a.String(), "bc"), a.String())
-		if strings.HasPrefix(a.String(), "bc1p") {
-			assert.Equal(t, 53, len(a.Bytes()), a.String())
-			a2, err := sdk.AccAddressFromBech32(a.String())
-			assert.NoError(t, err)
-			assert.Equal(t, 53, len(a2.Bytes()))
-		} else {
-			assert.Equal(t, 33, len(a.Bytes()), a.String())
-		}
-		// a2, err := sdk.AccAddressFromBech32(a.String())
-		// assert.Equal(t, 53, len(a2.Bytes()))
-		// assert.NoError(t, err, a.String())
-		// assert.Equal(t, a.Bytes(), a2.Bytes(), a.String())
-	}
+	// text := std.AddressSegWit.EncodeAddress()
+	// _, bte, err := bech32.Decode(text)
+	// assert.NoError(t, err)
+	// assert.Equal(t, 53, len(bte), text)
+	// a_str := sdk.MustAccAddressFromBech32(text)
+	// assert.Equal(t, 53, len(a_str.Bytes()), text)
+	// assert.Equal(t, bte, a_str.Bytes())
+
+	// btcutil.DecodeAddress()
+	// println("taproot:", len(taproot.GenPrivKey().PubKey().Address()))
+	a := segwit.GenPrivKey().PubKey().Address()
+	t.Log("segwit:", len(a), sdk.AccAddress(a).String())
+
+	// aa, _ := btcutil.NewAddressWitnessPubKeyHash(a.Bytes(), keys.Network)
+	// t.Log("aa", aa.EncodeAddress())
+
+	b := taproot.GenPrivKey().PubKey().Address()
+	t.Log("taproot:", len(b), sdk.AccAddress(b).String())
+	bb, _ := btcutil.NewAddressTaproot(b.Bytes(), bitcoin.Network)
+	t.Log("bb", bb.EncodeAddress())
+
+	// println("bech32:", text)
+	assert.Equal(t, sdk.AccAddress(b).String(), bb.EncodeAddress(), "bech32 address should be equal")
+
+	// addrs := []sdk.Address{sdk.AccAddress(taproot.GenPrivKey().PubKey().Address()), sdk.AccAddress(segwit.GenPrivKey().PubKey().Address())}
+
+	// for _, a := range addrs {
+	// 	println(len(a.Bytes()), a.String())
+	// 	assert.Equal(t, true, strings.HasPrefix(a.String(), "bc"), a.String())
+	// 	if strings.HasPrefix(a.String(), "bc1p") {
+	// 		assert.Equal(t, 32, len(a.Bytes()), a.String())
+	// 		a2, err := sdk.AccAddressFromBech32(a.String())
+	// 		assert.NoError(t, err)
+	// 		assert.Equal(t, 32, len(a2.Bytes()))
+	// 	} else {
+	// 		assert.Equal(t, 33, len(a.Bytes()), a.String())
+	// 	}
+	// 	// a2, err := sdk.AccAddressFromBech32(a.String())
+	// 	// assert.Equal(t, 53, len(a2.Bytes()))
+	// 	// assert.NoError(t, err, a.String())
+	// 	// assert.Equal(t, a.Bytes(), a2.Bytes(), a.String())
+	// }
 }
 
 func TestValAddressEncodeDecode(t *testing.T) {
@@ -100,19 +118,25 @@ func TestValAddressEncodeDecode(t *testing.T) {
 	vals := []string{
 		// "sidevaloper1qqwpwrc0qs0pvrc6rvrsxrc2p583vqstpgdqxxsmzgp3y9gfpvqp7srxm9c", // error case
 		// "sidevaloper1qqgsc9gfrqfsyrgtp5wpjqgkqct3cqq4rq8pj9cspcgszzqtzv2ssmdxyv7",
-		"sidevaloper1pfakusycd3aful428aqm6ljclu36vk6rzxqvu72g9e7jzaukswgnqd7xhsc",
-		"sidevaloper1p8990duvf0d23jelthdl2qgwfrrylny5zul0awymk7j45cjtm52eqqq7yxc",
-		"sidevaloper1qfwqngtkrmlytqkqsd54k9t4htufp0hw9sndewh",
+		"sidevaloper1qq9qjpswp5t3j9c8pq93xrc7zsysqpq6r5dqvpczpqz3yzqfrqwsc0aalqh",
+		"sidevaloper1l90rhzz8tka095tpvhjgzamvsvxyqhu34e9335l9npy2zx83lmcq9y82l7",
+		"sidevaloper1qqy3sqqmpv83xqcfry8qvyqazvqp6qqgru23y9q2q52swxggqg8sya58uzu",
+		"sidevaloper1qq0pkzghzcvsz8qwzcqq6xs6rv8qwxctzyzqq8shzy9qu8qhrcgsq8gftvt",
+		"sidevaloper1qqr3wzgzqvpqxycjzyr3kzcequxskxqxzydsjqgeqygq2xqxqgtpuaaajmf",
+		"sidevaloper1yezttrzdh00zmtzzfau9vuy360hxkjnl3gfxw2jzfqz67d8t8myq79pv5g",
 	}
 
 	for _, a := range vals {
 
 		addr, err := sdk.ValAddressFromBech32(a)
 		assert.NoError(t, err, "invalid address "+a)
+		t.Log("addr", addr.String())
 		if strings.HasPrefix(a, "sidevaloper1p") {
-			assert.Equal(t, 53, len(addr))
-		} else {
 			assert.Equal(t, 33, len(addr))
+		} else if strings.HasPrefix(a, "sidevaloper1q") {
+			assert.Equal(t, 33, len(addr))
+		} else {
+			assert.Equal(t, 32, len(addr))
 		}
 
 		text_addr := addr.String()

bitcoin/config.go

@@ -2,6 +2,7 @@ package bitcoin
 
 import (
 	storetypes "cosmossdk.io/store/types"
+	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/cosmos/cosmos-sdk/crypto/hd"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	"github.com/cosmos/cosmos-sdk/types/tx/signing"
@@ -12,6 +13,7 @@ import (
 )
 
 var (
+	Network       = &chaincfg.TestNet3Params
 	KeyringOption = func(options *keyring.Options) {
 		options.SupportedAlgos = keyring.SigningAlgoList{hd.Secp256k1, SegWit, Taproot}
 		options.SupportedAlgosLedger = keyring.SigningAlgoList{hd.Secp256k1}

bitcoin/keys/segwit/segwit.go

@@ -10,15 +10,14 @@ import (
 
 	secp256k1 "github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
-	"github.com/sideprotocol/side/bitcoin/keys"
+	"github.com/btcsuite/btcd/btcutil/bech32"
 
 	"github.com/cometbft/cometbft/crypto"
 
 	errorsmod "cosmossdk.io/errors"
 
 	//nolint: staticcheck
 
-	"github.com/cosmos/btcutil/bech32"
 	"github.com/cosmos/cosmos-sdk/codec"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	"github.com/cosmos/cosmos-sdk/types/errors"
@@ -164,28 +163,19 @@ func (pubKey *PubKey) Address() crypto.Address {
 
 	witnessProg := btcutil.Hash160(pubKey.Bytes())
 
-	bech32Address, err := btcutil.NewAddressWitnessPubKeyHash(witnessProg, keys.Network)
+	converted, err := bech32.ConvertBits(witnessProg, 8, 5, true)
 	if err != nil {
-		panic(err)
+		panic(err) // Handle this as needed
 	}
-	_, bz, err1 := bech32.Decode(bech32Address.String(), 1023)
-	if err1 != nil {
-		panic(err1)
-	}
-	return crypto.Address(bz)
 
-	// converted, err := bech32.ConvertBits(witnessProgram, 8, 5, true)
-	// if err != nil {
-	// 	panic(err)
-	// }
+	// Concatenate the witness version and program, and encode the resulting
+	// bytes using bech32 encoding.
+	combined := make([]byte, len(converted)+1)
+	combined[0] = 0x0
+	copy(combined[1:], converted)
 
-	// // Concatenate the witness version and program, and encode the resulting
-	// // bytes using bech32 encoding.
-	// combined := make([]byte, len(converted)+1)
-	// combined[0] = 0x0
-	// copy(combined[1:], converted)
+	return crypto.Address(combined)
 
-	// return crypto.Address(combined)
 }
 
 // Bytes returns the pubkey byte format.