aljaz/ark
1
0
Fork 0
mirror of https://github.com/aljazceru/ark.git synced 2025-12-17 20:24:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

Drop useless encoding (#110)

Browse Source 
* drop asec private key encoding

* remove pubkey/relaykey/url encoding in common pkg

* fix pubkey encoding

* remove SecKey
This commit is contained in:
Louis Singer
2024-02-20 17:35:11 +01:00
committed by GitHub
parent ffcf08420f
commit 936f9c5f51
9 changed files with 27 additions and 471 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
client/common.go
View File

@@ -119,12 +119,12 @@ func getWalletPublicKey() (*secp256k1.PublicKey, error) {
return nil, fmt.Errorf("public key not found")
}
_, publicKey, err := common.DecodePubKey(publicKeyString)
publicKeyBytes, err := hex.DecodeString(publicKeyString)
if err != nil {
return nil, err
}
return publicKey, nil
return secp256k1.ParsePubKey(publicKeyBytes)
}
func getServiceProviderPublicKey() (*secp256k1.PublicKey, error) {
@@ -138,12 +138,12 @@ func getServiceProviderPublicKey() (*secp256k1.PublicKey, error) {
return nil, fmt.Errorf("ark public key not found")
}
_, pubKey, err := common.DecodePubKey(arkPubKey)
pubKeyBytes, err := hex.DecodeString(arkPubKey)
if err != nil {
return nil, err
}
return pubKey, nil
return secp256k1.ParsePubKey(pubKeyBytes)
}
func coinSelect(vtxos []vtxo, amount uint64) ([]vtxo, uint64, error) {

14
client/init.go
View File

@@ -6,7 +6,6 @@ import (
"strings"
arkv1 "github.com/ark-network/ark/api-spec/protobuf/gen/ark/v1"
"github.com/ark-network/ark/common"
"github.com/btcsuite/btcd/btcec/v2"
"github.com/decred/dcrd/dcrec/secp256k1/v4"
"github.com/urfave/cli/v2"
@@ -108,16 +107,7 @@ func initWallet(ctx *cli.Context, key, password string) error {
privateKey = secp256k1.PrivKeyFromBytes(privKeyBytes)
}
cypher := NewAES128Cypher()
arkNetwork, _ := getNetwork()
publicKey, err := common.EncodePubKey(arkNetwork.PubKey, privateKey.PubKey())
if err != nil {
return err
}
encryptedPrivateKey, err := cypher.Encrypt(privateKey.Serialize(), []byte(password))
encryptedPrivateKey, err := NewAES128Cypher().Encrypt(privateKey.Serialize(), []byte(password))
if err != nil {
return err
}
@@ -127,7 +117,7 @@ func initWallet(ctx *cli.Context, key, password string) error {
state := map[string]string{
"encrypted_private_key": hex.EncodeToString(encryptedPrivateKey),
"password_hash": hex.EncodeToString(passwordHash),
"public_key": publicKey,
"public_key": hex.EncodeToString(privateKey.PubKey().SerializeCompressed()),
}
if err := setState(state); err != nil {

177
common/encoding.go
View File

@@ -2,95 +2,11 @@ package common
import (
"fmt"
"net/url"
"strings"
"github.com/btcsuite/btcd/btcutil/bech32"
"github.com/decred/dcrd/dcrec/secp256k1/v4"
)
const (
ProtoKey = "ark"
RelayKey = "relays"
RelaySep = "-"
)
func EncodeSecKey(hrp string, key *secp256k1.PrivateKey) (seckey string, err error) {
if key == nil {
return "", fmt.Errorf("missing secret key")
}
if hrp != MainNet.SecKey && hrp != TestNet.SecKey {
return "", fmt.Errorf("invalid prefix")
}
grp, err := bech32.ConvertBits(key.Serialize(), 8, 5, true)
if err != nil {
return "", err
}
seckey, err = bech32.EncodeM(hrp, grp)
return
}
func DecodeSecKey(key string) (hrp string, seckey *secp256k1.PrivateKey, err error) {
prefix, buf, err := bech32.DecodeNoLimit(key)
if err != nil {
err = fmt.Errorf("invalid secret key: %s", err)
return
}
if prefix != MainNet.SecKey && prefix != TestNet.SecKey {
err = fmt.Errorf("invalid prefix")
return
}
grp, err := bech32.ConvertBits(buf, 5, 8, false)
if err != nil {
return
}
hrp = prefix
seckey = secp256k1.PrivKeyFromBytes(grp)
return
}
func EncodePubKey(hrp string, key *secp256k1.PublicKey) (pubkey string, err error) {
if key == nil {
err = fmt.Errorf("missing public key")
return
}
if hrp != MainNet.PubKey && hrp != TestNet.PubKey {
err = fmt.Errorf("invalid prefix")
return
}
grp, err := bech32.ConvertBits(key.SerializeCompressed(), 8, 5, true)
if err != nil {
return
}
pubkey, err = bech32.EncodeM(hrp, grp)
return
}
func DecodePubKey(key string) (hrp string, pubkey *secp256k1.PublicKey, err error) {
prefix, buf, err := bech32.DecodeNoLimit(key)
if err != nil {
return
}
if prefix != MainNet.PubKey && prefix != TestNet.PubKey {
err = fmt.Errorf("invalid prefix")
return
}
grp, err := bech32.ConvertBits(buf, 5, 8, false)
if err != nil {
return
}
if len(grp) < 32 {
err = fmt.Errorf("invalid public key length")
return
}
pubkey, err = secp256k1.ParsePubKey(grp)
if err != nil {
return
}
hrp = prefix
return
}
func EncodeAddress(hrp string, userKey, aspKey *secp256k1.PublicKey) (addr string, err error) {
if userKey == nil {
err = fmt.Errorf("missing public key")
@@ -141,96 +57,3 @@ func DecodeAddress(addr string) (hrp string, userKey *secp256k1.PublicKey, aspKe
aspKey = aKey
return
}
func EncodeRelayKey(hrp string, key *secp256k1.PublicKey) (pubkey string, err error) {
if key == nil {
err = fmt.Errorf("missing relay key")
return
}
if hrp != MainNet.RelayKey && hrp != TestNet.RelayKey {
err = fmt.Errorf("invalid prefix")
return
}
grp, err := bech32.ConvertBits(key.SerializeCompressed(), 8, 5, true)
if err != nil {
return
}
pubkey, err = bech32.EncodeM(hrp, grp)
return
}
func DecodeRelayKey(key string) (hrp string, pubkey *secp256k1.PublicKey, err error) {
prefix, buf, err := bech32.DecodeNoLimit(key)
if err != nil {
return
}
if prefix != MainNet.RelayKey && prefix != TestNet.RelayKey {
err = fmt.Errorf("invalid prefix")
return
}
grp, err := bech32.ConvertBits(buf, 5, 8, false)
if err != nil {
return
}
if len(grp) < 32 {
err = fmt.Errorf("invalid public key length")
return
}
pubkey, err = secp256k1.ParsePubKey(grp)
if err != nil {
return
}
hrp = prefix
return
}
func EncodeUrl(host string, relays ...string) (arkurl string, err error) {
_, _, err = DecodePubKey(host)
if err != nil {
err = fmt.Errorf("invalid public key: %s", err)
return
}
for _, r := range relays {
_, _, err = DecodeRelayKey(r)
if err != nil {
err = fmt.Errorf("invalid relay public key: %s", err)
return
}
}
u := url.URL{Scheme: ProtoKey, Host: host}
q := u.Query()
if len(relays) > 0 {
q.Add(RelayKey, strings.Join(relays, RelaySep))
}
u.RawQuery = q.Encode()
arkurl = u.String()
return
}
func DecodeUrl(arkurl string) (host string, relays []string, err error) {
u, err := url.Parse(arkurl)
if err != nil {
return
}
if u.Scheme != ProtoKey {
err = fmt.Errorf("invalid proto")
return
}
_, _, err = DecodePubKey(u.Host)
if err != nil {
err = fmt.Errorf("invalid public key: %s", err)
return
}
list := strings.Split(u.Query().Get(RelayKey), RelaySep)
for _, r := range list {
_, _, err = DecodeRelayKey(r)
if err != nil {
err = fmt.Errorf("invalid relay public key: %s", err)
return
}
}
host = u.Host
relays = make([]string, len(list))
copy(relays, list)
return
}

176
common/encoding_test.go
View File

@@ -21,90 +21,6 @@ func init() {
}
}
func TestSecretKeyEncoding(t *testing.T) {
fixtures := struct {
SecretKey struct {
Valid []struct {
Key string `json:"key"`
Expected string `json:"expected"`
} `json:"valid"`
Invalid []struct {
Key string `json:"key"`
ExpectedError string `json:"expectedError"`
} `json:"invalid"`
} `json:"secretKey"`
}{}
err := json.Unmarshal(f, &fixtures)
require.NoError(t, err)
t.Run("valid", func(t *testing.T) {
for _, f := range fixtures.SecretKey.Valid {
hrp, key, err := common.DecodeSecKey(f.Key)
require.NoError(t, err)
require.NotEmpty(t, hrp)
require.NotNil(t, key)
keyHex := hex.EncodeToString(key.Serialize())
require.Equal(t, f.Expected, keyHex)
keyStr, err := common.EncodeSecKey(hrp, key)
require.NoError(t, err)
require.Equal(t, f.Key, keyStr)
}
})
t.Run("invalid", func(t *testing.T) {
for _, f := range fixtures.SecretKey.Invalid {
hrp, key, err := common.DecodeSecKey(f.Key)
require.EqualError(t, err, f.ExpectedError)
require.Empty(t, hrp)
require.Nil(t, key)
}
})
}
func TestPublicKeyEncoding(t *testing.T) {
fixtures := struct {
PublicKey struct {
Valid []struct {
Key string `json:"key"`
Expected string `json:"expected"`
} `json:"valid"`
Invalid []struct {
Key string `json:"key"`
ExpectedError string `json:"expectedError"`
} `json:"invalid"`
} `json:"publicKey"`
}{}
err := json.Unmarshal(f, &fixtures)
require.NoError(t, err)
t.Run("valid", func(t *testing.T) {
for _, f := range fixtures.PublicKey.Valid {
hrp, key, err := common.DecodePubKey(f.Key)
require.NoError(t, err)
require.NotEmpty(t, hrp)
require.NotNil(t, key)
keyHex := hex.EncodeToString(key.SerializeCompressed())
require.Equal(t, f.Expected, keyHex)
keyStr, err := common.EncodePubKey(hrp, key)
require.NoError(t, err)
require.Equal(t, f.Key, keyStr)
}
})
t.Run("invalid", func(t *testing.T) {
for _, f := range fixtures.PublicKey.Invalid {
hrp, key, err := common.DecodePubKey(f.Key)
require.EqualError(t, err, f.ExpectedError)
require.Empty(t, hrp)
require.Nil(t, key)
}
})
}
func TestAddressEncoding(t *testing.T) {
fixtures := struct {
Address struct {
@@ -130,13 +46,11 @@ func TestAddressEncoding(t *testing.T) {
require.NotNil(t, userKey)
require.NotNil(t, aspKey)
userKeyStr, err := common.EncodePubKey(common.MainNet.PubKey, userKey)
require.NoError(t, err)
require.Equal(t, f.ExpectedUserKey, userKeyStr)
require.Equal(t, f.ExpectedUserKey, hex.EncodeToString(userKey.SerializeCompressed()))
aspKeyStr, err := common.EncodePubKey(common.MainNet.PubKey, aspKey)
require.NoError(t, err)
require.Equal(t, f.ExpectedAspKey, aspKeyStr)
require.Equal(t, f.ExpectedAspKey, hex.EncodeToString(aspKey.SerializeCompressed()))
addr, err := common.EncodeAddress(hrp, userKey, aspKey)
require.NoError(t, err)
@@ -154,89 +68,3 @@ func TestAddressEncoding(t *testing.T) {
}
})
}
func TestRelayKeyEncoding(t *testing.T) {
fixtures := struct {
RelayKey struct {
Valid []struct {
Key string `json:"key"`
Expected string `json:"expected"`
} `json:"valid"`
Invalid []struct {
Key string `json:"key"`
ExpectedError string `json:"expectedError"`
} `json:"invalid"`
} `json:"relayKey"`
}{}
err := json.Unmarshal(f, &fixtures)
require.NoError(t, err)
t.Run("valid", func(t *testing.T) {
for _, f := range fixtures.RelayKey.Valid {
hrp, key, err := common.DecodeRelayKey(f.Key)
require.NoError(t, err)
require.NotEmpty(t, hrp)
require.NotNil(t, key)
keyHex := hex.EncodeToString(key.SerializeCompressed())
require.Equal(t, f.Expected, keyHex)
keyStr, err := common.EncodeRelayKey(hrp, key)
require.NoError(t, err)
require.Equal(t, f.Key, keyStr)
}
})
t.Run("invalid", func(t *testing.T) {
for _, f := range fixtures.RelayKey.Invalid {
hrp, key, err := common.DecodeRelayKey(f.Key)
require.EqualError(t, err, f.ExpectedError)
require.Empty(t, hrp)
require.Nil(t, key)
}
})
}
func TestUrlEncoding(t *testing.T) {
fixtures := struct {
Url struct {
Valid []struct {
Url string `json:"url"`
ExpectedPubkey string `json:"expectedPubkey"`
ExpectedRelays []string `json:"expectedRelays"`
} `json:"valid"`
Invalid []struct {
Url string `json:"url"`
ExpectedError string `json:"expectedError"`
} `json:"invalid"`
} `json:"url"`
}{}
err := json.Unmarshal(f, &fixtures)
require.NoError(t, err)
t.Run("valid", func(t *testing.T) {
for _, f := range fixtures.Url.Valid {
pubkey, relays, err := common.DecodeUrl(f.Url)
require.NoError(t, err)
require.NotEmpty(t, pubkey)
require.NotNil(t, relays)
require.Equal(t, f.ExpectedPubkey, pubkey)
require.Exactly(t, relays, f.ExpectedRelays)
url, err := common.EncodeUrl(pubkey, relays...)
require.NoError(t, err)
require.Equal(t, f.Url, url)
}
})
t.Run("invalid", func(t *testing.T) {
for _, f := range fixtures.Url.Invalid {
pubkey, relays, err := common.DecodeUrl(f.Url)
require.Error(t, err)
require.Contains(t, err.Error(), f.ExpectedError)
require.Empty(t, pubkey)
require.Nil(t, relays)
}
})
}

72
common/fixtures/encoding.json
View File

@@ -1,38 +1,10 @@
{
"secretKey": {
"valid": [
{
"key": "asec1n9grggypds323l5fkw4t6kpf6trz26an8wv44qqr8ctp4t3dp52q5zkzz4",
"expected": "99503420816c22a8fe89b3aabd5829d2c6256bb33b995a80033e161aae2d0d14"
}
],
"invalid": [
{
"key": "wrongprefix1c02kjhr4egxvh0ajua0ylv9vl3kyegxmrl2djh4pn63m948ecs4qchx9zx",
"expectedError": "invalid prefix"
}
]
},
"publicKey": {
"valid": [
{
"key": "apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x",
"expected": "0218d5ca8b58797b7dbd65c075dd7ba7784b3f38ab71b1a5a8e3f94ba0257654a6"
}
],
"invalid": [
{
"key": "wrongprefix1q0yn8cskp7lv0lxq3unfynmju68smh69lu90yyv37wzetu6upp76vg4ef6n",
"expectedError": "invalid prefix"
}
]
},
"address": {
"valid": [
{
"addr": "ark1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22vqa7mdkrrulzu48law4zzvzz8k59hul0ayl2urt905we5wf6gee68sfrfj35",
"expectedUserKey": "apub1qwldkmp3703w2nl7h23pxpprm2zm70h7j04wp4jh68v68yayvuarcc28uv5",
"expectedAspKey": "apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x"
"expectedUserKey": "03bedb6c31f3e2e54ffebaa2130423da85bf3efe93eae0d657d1d9a393a4673a3c",
"expectedAspKey": "0218d5ca8b58797b7dbd65c075dd7ba7784b3f38ab71b1a5a8e3f94ba0257654a6"
}
],
"invalid": [
@@ -41,45 +13,5 @@
"expectedError": "invalid prefix"
}
]
},
"relayKey": {
"valid": [
{
"key": "arelay1qt6f8p7h5f6tm7fv2z5wg92sz92rn9desfhd5733se4lkrptqtdrq65987l",
"expected": "02f49387d7a274bdf92c50a8e4155011543995b9826eda7a31866bfb0c2b02da30"
}
],
"invalid": [
{
"key": "wrongprefix1q2g64uehct5zdkhdull6ultevfmuu62nzwucec6q8su85eqpezxdvsf2mfd",
"expectedError": "invalid prefix"
}
]
},
"url": {
"valid": [
{
"url": "ark://apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x?relays=arelay1qt6f8p7h5f6tm7fv2z5wg92sz92rn9desfhd5733se4lkrptqtdrq65987l-arelay1qt6f8p7h5f6tm7fv2z5wg92sz92rn9desfhd5733se4lkrptqtdrq65987l",
"expectedPubkey": "apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x",
"expectedRelays": [
"arelay1qt6f8p7h5f6tm7fv2z5wg92sz92rn9desfhd5733se4lkrptqtdrq65987l",
"arelay1qt6f8p7h5f6tm7fv2z5wg92sz92rn9desfhd5733se4lkrptqtdrq65987l"
]
}
],
"invalid": [
{
"url": "wrong://apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x?relays=arelay1qt6f8p7h5f6tm7fv2z5wg92sz92rn9desfhd5733se4lkrptqtdrq65987l-arelay1qt6f8p7h5f6tm7fv2z5wg92sz92rn9desfhd5733se4lkrptqtdrq65987l",
"expectedError": "invalid proto"
},
{
"url": "ark://asec1n9grggypds323l5fkw4t6kpf6trz26an8wv44qqr8ctp4t3dp52qun9kjh",
"expectedError": "invalid public key"
},
{
"url": "ark://apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x?relays=apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x",
"expectedError": "invalid relay public key"
}
]
}
}

21
common/network.go
View File

@@ -1,25 +1,16 @@
package common
type Network struct {
Name string
SecKey string
PubKey string
RelayKey string
Addr string
Name string
Addr string
}
var MainNet = Network{
Name: "mainnet",
SecKey: "asec",
PubKey: "apub",
RelayKey: "arelay",
Addr: "ark",
Name: "mainnet",
Addr: "ark",
}
var TestNet = Network{
Name: "testnet",
SecKey: "tasec",
PubKey: "tapub",
RelayKey: "tarelay",
Addr: "tark",
Name: "testnet",
Addr: "tark",
}

6
server/internal/core/application/service.go
View File

@@ -219,11 +219,7 @@ func (s *service) GetRoundByTxid(ctx context.Context, poolTxid string) (*domain.
}
func (s *service) GetPubkey(ctx context.Context) (string, error) {
pubkey, err := common.EncodePubKey(s.network.PubKey, s.pubkey)
if err != nil {
return "", err
}
return pubkey, nil
return hex.EncodeToString(s.pubkey.SerializeCompressed()), nil
}
func (s *service) start() {

6
server/internal/infrastructure/tx-builder/covenant/builder_test.go
View File

@@ -7,7 +7,6 @@ import (
"os"
"testing"
"github.com/ark-network/ark/common"
"github.com/ark-network/ark/common/tree"
"github.com/ark-network/ark/internal/core/domain"
"github.com/ark-network/ark/internal/core/ports"
@@ -21,7 +20,7 @@ import (
)
const (
testingKey = "apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x"
testingKey = "0218d5ca8b58797b7dbd65c075dd7ba7784b3f38ab71b1a5a8e3f94ba0257654a6"
minRelayFee = uint64(30)
roundLifetime = int64(1209344)
)
@@ -38,7 +37,8 @@ func TestMain(m *testing.M) {
wallet.On("SelectUtxos", mock.Anything, mock.Anything, mock.Anything).
Return(randomInput, uint64(0), nil)
_, pubkey, _ = common.DecodePubKey(testingKey)
pubkeyBytes, _ := hex.DecodeString(testingKey)
pubkey, _ = secp256k1.ParsePubKey(pubkeyBytes)
os.Exit(m.Run())
}

18
server/internal/infrastructure/tx-builder/dummy/builder_test.go
View File

@@ -6,7 +6,6 @@ import (
"encoding/hex"
"testing"
"github.com/ark-network/ark/common"
"github.com/ark-network/ark/internal/core/domain"
"github.com/ark-network/ark/internal/core/ports"
txbuilder "github.com/ark-network/ark/internal/infrastructure/tx-builder/dummy"
@@ -18,7 +17,7 @@ import (
)
const (
testingKey = "apub1qgvdtj5ttpuhkldavhq8thtm5auyk0ec4dcmrfdgu0u5hgp9we22v3hrs4x"
testingKey = "0218d5ca8b58797b7dbd65c075dd7ba7784b3f38ab71b1a5a8e3f94ba0257654a6"
fakePoolTx = "cHNldP8BAgQCAAAAAQQBAQEFAQMBBgEDAfsEAgAAAAABDiDk7dXxh4KQzgLO8i1ABtaLCe4aPL12GVhN1E9zM1ePLwEPBAAAAAABEAT/////AAEDCOgDAAAAAAAAAQQWABSNnpy01UJqd99eTg2M1IpdKId11gf8BHBzZXQCICWyUQcOKcoZBDzzPM1zJOLdqwPsxK4LXnfE/A5c9slaB/wEcHNldAgEAAAAAAABAwh4BQAAAAAAAAEEFgAUjZ6ctNVCanffXk4NjNSKXSiHddYH/ARwc2V0AiAlslEHDinKGQQ88zzNcyTi3asD7MSuC153xPwOXPbJWgf8BHBzZXQIBAAAAAAAAQMI9AEAAAAAAAABBAAH/ARwc2V0AiAlslEHDinKGQQ88zzNcyTi3asD7MSuC153xPwOXPbJWgf8BHBzZXQIBAAAAAAA"
)
@@ -238,13 +237,11 @@ func TestBuildCongestionTree(t *testing.T) {
expectedLeavesNum: 6,
},
}
_, key, err := common.DecodePubKey(testingKey)
require.NoError(t, err)
require.NotNil(t, key)
pubkeyBytes, _ := hex.DecodeString(testingKey)
pubkey, _ := secp256k1.ParsePubKey(pubkeyBytes)
for _, f := range fixtures {
poolTx, tree, err := builder.BuildPoolTx(key, f.payments, 30)
poolTx, tree, err := builder.BuildPoolTx(pubkey, f.payments, 30)
require.NoError(t, err)
require.Equal(t, f.expectedNodesNum, tree.NumberOfNodes())
@@ -352,13 +349,12 @@ func TestBuildForfeitTxs(t *testing.T) {
},
}
_, key, err := common.DecodePubKey(testingKey)
require.NoError(t, err)
require.NotNil(t, key)
pubkeyBytes, _ := hex.DecodeString(testingKey)
pubkey, _ := secp256k1.ParsePubKey(pubkeyBytes)
for _, f := range fixtures {
connectors, forfeitTxs, err := builder.BuildForfeitTxs(
key, fakePoolTx, f.payments,
pubkey, fakePoolTx, f.payments,
)
require.NoError(t, err)
require.Len(t, connectors, f.expectedNumOfConnectors)