tmp

.github/workflows/docker.yml

@@ -51,15 +51,7 @@ jobs:
       - name: Build image and push
         run: |
           cd peggo/
-          TAG=$(echo ${GITHUB_REF#refs/heads/} | cut -d '/' -f 2)
+          TAG=${{ github.ref_name }}
           echo $TAG
           [[ $ECR_ENABLED == "false" ]] || docker buildx build --tag $ECR_REPO:$TAG --platform linux/amd64,linux/arm64 --push .
           [[ $GHCR_ENABLED == "false" ]] || docker buildx build --tag $GHCR_REPO:$TAG --platform linux/amd64,linux/arm64 --push .
-
-      - name: NONROOT Build image and push
-        run: |
-          cd peggo/
-          TAG=$(echo ${GITHUB_REF#refs/heads/} | cut -d '/' -f 2)-nonroot
-          echo $TAG
-          [[ $ECR_ENABLED == "false" ]] || docker buildx build -f Dockerfile.nonroot --tag $ECR_REPO:$TAG --platform linux/amd64,linux/arm64 --push .
-          [[ $GHCR_ENABLED == "false" ]] || docker buildx build -f Dockerfile.nonroot --tag $GHCR_REPO:$TAG --platform linux/amd64,linux/arm64 --push .

cmd/peggo/keys.go

@@ -2,20 +2,13 @@ package main
 
 import (
 	"bytes"
-	"crypto/rand"
 	"fmt"
 	"io"
-	"log"
 	"math/big"
 	"os"
-	"path/filepath"
 	"strings"
 	"syscall"
 
-	cosmcrypto "github.com/cosmos/cosmos-sdk/crypto"
-	"github.com/cosmos/cosmos-sdk/crypto/keyring"
-	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
-	cosmtypes "github.com/cosmos/cosmos-sdk/types"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/accounts/usbwallet"
@@ -27,154 +20,9 @@ import (
 	"github.com/pkg/errors"
 	"golang.org/x/crypto/ssh/terminal"
 
-	"github.com/InjectiveLabs/sdk-go/chain/crypto/ethsecp256k1"
-	"github.com/InjectiveLabs/sdk-go/chain/crypto/hd"
-
 	"github.com/InjectiveLabs/peggo/orchestrator/ethereum/keystore"
 )
 
-const defaultKeyringKeyName = "validator"
-
-var emptyCosmosAddress = cosmtypes.AccAddress{}
-var cdc = MakeEncodingConfig().Marshaler
-
-func initCosmosKeyring(
-	cosmosKeyringDir *string,
-	cosmosKeyringAppName *string,
-	cosmosKeyringBackend *string,
-	cosmosKeyFrom *string,
-	cosmosKeyPassphrase *string,
-	cosmosPrivKey *string,
-	cosmosUseLedger *bool,
-) (cosmtypes.AccAddress, keyring.Keyring, error) {
-
-	switch {
-	case len(*cosmosPrivKey) > 0:
-		if *cosmosUseLedger {
-			err := errors.New("cannot combine ledger and privkey options")
-			return emptyCosmosAddress, nil, err
-		}
-
-		pkBytes, err := hexToBytes(*cosmosPrivKey)
-		if err != nil {
-			err = errors.Wrap(err, "failed to hex-decode cosmos account privkey")
-			return emptyCosmosAddress, nil, err
-		}
-
-		// Specfic to Injective chain with Ethermint keys
-		// Should be secp256k1.PrivKey for generic Cosmos chain
-		cosmosAccPk := &ethsecp256k1.PrivKey{
-			Key: pkBytes,
-		}
-
-		addressFromPk := cosmtypes.AccAddress(cosmosAccPk.PubKey().Address().Bytes())
-
-		var keyName string
-
-		// check that if cosmos 'From' specified separately, it must match the provided privkey,
-		if len(*cosmosKeyFrom) > 0 {
-			addressFrom, err := cosmtypes.AccAddressFromBech32(*cosmosKeyFrom)
-			if err == nil {
-				if !bytes.Equal(addressFrom.Bytes(), addressFromPk.Bytes()) {
-					err = errors.Errorf("expected account address %s but got %s from the private key", addressFrom.String(), addressFromPk.String())
-					return emptyCosmosAddress, nil, err
-				}
-			} else {
-				// use it as a name then
-				keyName = *cosmosKeyFrom
-			}
-		}
-
-		if len(keyName) == 0 {
-			keyName = defaultKeyringKeyName
-		}
-
-		// wrap a PK into a Keyring
-		kb, err := KeyringForPrivKey(keyName, cosmosAccPk)
-		return addressFromPk, kb, err
-
-	case len(*cosmosKeyFrom) > 0:
-		var fromIsAddress bool
-		addressFrom, err := cosmtypes.AccAddressFromBech32(*cosmosKeyFrom)
-		if err == nil {
-			fromIsAddress = true
-		}
-
-		var passReader io.Reader = os.Stdin
-		if len(*cosmosKeyPassphrase) > 0 {
-			passReader = newPassReader(*cosmosKeyPassphrase)
-		}
-
-		var absoluteKeyringDir string
-		if filepath.IsAbs(*cosmosKeyringDir) {
-			absoluteKeyringDir = *cosmosKeyringDir
-		} else {
-			absoluteKeyringDir, _ = filepath.Abs(*cosmosKeyringDir)
-		}
-
-		kb, err := keyring.New(
-			*cosmosKeyringAppName,
-			*cosmosKeyringBackend,
-			absoluteKeyringDir,
-			passReader,
-			cdc,
-			hd.EthSecp256k1Option(),
-		)
-		if err != nil {
-			err = errors.Wrap(err, "failed to init keyring")
-			return emptyCosmosAddress, nil, err
-		}
-
-		var keyInfo *keyring.Record
-		if fromIsAddress {
-			if keyInfo, err = kb.KeyByAddress(addressFrom); err != nil {
-				err = errors.Wrapf(err, "couldn't find an entry for the key %s in keybase", addressFrom.String())
-				return emptyCosmosAddress, nil, err
-			}
-		} else {
-			if keyInfo, err = kb.Key(*cosmosKeyFrom); err != nil {
-				err = errors.Wrapf(err, "could not find an entry for the key '%s' in keybase", *cosmosKeyFrom)
-				return emptyCosmosAddress, nil, err
-			}
-		}
-
-		switch keyType := keyInfo.GetType(); keyType {
-		case keyring.TypeLocal:
-			// kb has a key and it's totally usable
-			addr, err := keyInfo.GetAddress()
-			if err != nil {
-				return emptyCosmosAddress, nil, err
-			}
-			return addr, kb, nil
-		case keyring.TypeLedger:
-			// the kb stores references to ledger keys, so we must explicitly
-			// check that. kb doesn't know how to scan HD keys - they must be added manually before
-			if *cosmosUseLedger {
-				addr, err := keyInfo.GetAddress()
-				if err != nil {
-					return emptyCosmosAddress, nil, err
-				}
-				return addr, kb, nil
-			}
-			err := errors.Errorf("'%s' key is a ledger reference, enable ledger option", keyInfo.Name)
-			return emptyCosmosAddress, nil, err
-		case keyring.TypeOffline:
-			err := errors.Errorf("'%s' key is an offline key, not supported yet", keyInfo.Name)
-			return emptyCosmosAddress, nil, err
-		case keyring.TypeMulti:
-			err := errors.Errorf("'%s' key is an multisig key, not supported yet", keyInfo.Name)
-			return emptyCosmosAddress, nil, err
-		default:
-			err := errors.Errorf("'%s' key  has unsupported type: %s", keyInfo.Name, keyType)
-			return emptyCosmosAddress, nil, err
-		}
-
-	default:
-		err := errors.New("insufficient cosmos key details provided")
-		return emptyCosmosAddress, nil, err
-	}
-}
-
 var emptyEthAddress = ethcmn.Address{}
 
 func initEthereumAccountsManager(
@@ -392,32 +240,3 @@ func (r *passReader) Read(p []byte) (n int, err error) {
 
 	return
 }
-
-// KeyringForPrivKey creates a temporary in-mem keyring for a PrivKey.
-// Allows to init Context when the key has been provided in plaintext and parsed.
-func KeyringForPrivKey(name string, privKey cryptotypes.PrivKey) (keyring.Keyring, error) {
-	kb := keyring.NewInMemory(cdc, hd.EthSecp256k1Option())
-	tmpPhrase := randPhrase(64)
-	armored := cosmcrypto.EncryptArmorPrivKey(privKey, tmpPhrase, privKey.Type())
-	err := kb.ImportPrivKey(name, armored, tmpPhrase)
-	if err != nil {
-		err = errors.Wrap(err, "failed to import privkey")
-		return nil, err
-	}
-
-	return kb, nil
-}
-
-func randPhrase(size int) string {
-	buf := make([]byte, size)
-	_, err := rand.Read(buf)
-	orPanic(err)
-
-	return string(buf)
-}
-
-func orPanic(err error) {
-	if err != nil {
-		log.Panicln()
-	}
-}