github.com/koko1123/flow-go-1@v0.29.6/fvm/environment/account_key_reader.go

package environment

import (
	"fmt"

	"github.com/onflow/cadence/runtime"

	"github.com/koko1123/flow-go-1/fvm/crypto"
	"github.com/koko1123/flow-go-1/fvm/errors"
	"github.com/koko1123/flow-go-1/fvm/state"
	"github.com/koko1123/flow-go-1/fvm/tracing"
	"github.com/koko1123/flow-go-1/model/flow"
	"github.com/koko1123/flow-go-1/module/trace"
)

// AccountKeyReader provide read access to account keys.
type AccountKeyReader interface {
	// GetAccountKey retrieves a public key by index from an existing account.
	//
	// This function returns a nil key with no errors, if a key doesn't exist at
	// the given index. An error is returned if the specified account does not
	// exist, the provided index is not valid, or if the key retrieval fails.
	GetAccountKey(
		address runtime.Address,
		keyIndex int,
	) (
		*runtime.AccountKey,
		error,
	)
	AccountKeysCount(address runtime.Address) (uint64, error)
}

type ParseRestrictedAccountKeyReader struct {
	txnState *state.TransactionState
	impl     AccountKeyReader
}

func NewParseRestrictedAccountKeyReader(
	txnState *state.TransactionState,
	impl AccountKeyReader,
) AccountKeyReader {
	return ParseRestrictedAccountKeyReader{
		txnState: txnState,
		impl:     impl,
	}
}

func (reader ParseRestrictedAccountKeyReader) GetAccountKey(
	address runtime.Address,
	keyIndex int,
) (
	*runtime.AccountKey,
	error,
) {
	return parseRestrict2Arg1Ret(
		reader.txnState,
		trace.FVMEnvGetAccountKey,
		reader.impl.GetAccountKey,
		address,
		keyIndex)
}

func (reader ParseRestrictedAccountKeyReader) AccountKeysCount(address runtime.Address) (uint64, error) {
	return parseRestrict1Arg1Ret(
		reader.txnState,
		"AccountKeysCount",
		reader.impl.AccountKeysCount,
		address,
	)
}

type accountKeyReader struct {
	tracer tracing.TracerSpan
	meter  Meter

	accounts Accounts
}

func NewAccountKeyReader(
	tracer tracing.TracerSpan,
	meter Meter,
	accounts Accounts,
) AccountKeyReader {
	return &accountKeyReader{
		tracer:   tracer,
		meter:    meter,
		accounts: accounts,
	}
}

func (reader *accountKeyReader) GetAccountKey(
	address runtime.Address,
	keyIndex int,
) (
	*runtime.AccountKey,
	error,
) {
	defer reader.tracer.StartChildSpan(trace.FVMEnvGetAccountKey).End()

	formatErr := func(err error) (*runtime.AccountKey, error) {
		return nil, fmt.Errorf("getting account key failed: %w", err)
	}

	err := reader.meter.MeterComputation(ComputationKindGetAccountKey, 1)
	if err != nil {
		return formatErr(err)
	}

	// Don't return an error for invalid key indices
	if keyIndex < 0 {
		return nil, nil
	}

	accountAddress := flow.Address(address)

	// address verification is also done in this step
	accountPublicKey, err := reader.accounts.GetPublicKey(
		accountAddress,
		uint64(keyIndex))
	if err != nil {
		// If a key is not found at a given index, then return a nil key with
		// no errors.  This is to be inline with the Cadence runtime. Otherwise,
		// Cadence runtime cannot distinguish between a 'key not found error'
		// vs other internal errors.
		if errors.IsAccountAccountPublicKeyNotFoundError(err) {
			return nil, nil
		}

		return formatErr(err)
	}

	// Prepare the account key to return
	runtimeAccountKey, err := FlowToRuntimeAccountKey(accountPublicKey)
	if err != nil {
		return formatErr(err)
	}

	return runtimeAccountKey, nil
}

func (reader *accountKeyReader) AccountKeysCount(address runtime.Address) (uint64, error) {
	defer reader.tracer.StartChildSpan(trace.FVMEnvAccountKeysCount).End()

	formatErr := func(err error) (uint64, error) {
		return 0, fmt.Errorf("fetching account key count failed: %w", err)
	}

	err := reader.meter.MeterComputation(ComputationKindAccountKeysCount, 1)
	if err != nil {
		return formatErr(err)
	}

	accountAddress := flow.Address(address)

	// address verification is also done in this step
	return reader.accounts.GetPublicKeyCount(accountAddress)
}

func FlowToRuntimeAccountKey(flowKey flow.AccountPublicKey) (*runtime.AccountKey, error) {
	signAlgo := crypto.CryptoToRuntimeSigningAlgorithm(flowKey.SignAlgo)
	if signAlgo == runtime.SignatureAlgorithmUnknown {
		return nil, errors.NewValueErrorf(
			flowKey.SignAlgo.String(),
			"signature algorithm type not found",
		)
	}

	hashAlgo := crypto.CryptoToRuntimeHashingAlgorithm(flowKey.HashAlgo)
	if hashAlgo == runtime.HashAlgorithmUnknown {
		return nil, errors.NewValueErrorf(
			flowKey.HashAlgo.String(),
			"hashing algorithm type not found",
		)
	}

	publicKey := &runtime.PublicKey{
		PublicKey: flowKey.PublicKey.Encode(),
		SignAlgo:  signAlgo,
	}

	return &runtime.AccountKey{
		KeyIndex:  flowKey.Index,
		PublicKey: publicKey,
		HashAlgo:  hashAlgo,
		Weight:    flowKey.Weight,
		IsRevoked: flowKey.Revoked,
	}, nil
}