aboutsummaryrefslogtreecommitdiff
path: root/plugin/evm
diff options
context:
space:
mode:
authoraaronbuchwald <[email protected]>2020-11-09 11:43:04 -0500
committerGitHub <[email protected]>2020-11-09 11:43:04 -0500
commitff462c343e87ba3ab38d7aad95e3a85408f38bb0 (patch)
tree1adf2f3f8bdaafd4c3fae12524d5ba94db8440f3 /plugin/evm
parent24cf772145b7d976fff613a51b7d22f70fc1ac34 (diff)
parent3a887bbc7b7d88070dbcdb1104119bce282ed249 (diff)
Merge pull request #48 from ava-labs/atomic-api
Atomic api
Diffstat (limited to 'plugin/evm')
-rw-r--r--plugin/evm/service.go164
-rw-r--r--plugin/evm/tx.go2
-rw-r--r--plugin/evm/vm.go41
3 files changed, 203 insertions, 4 deletions
diff --git a/plugin/evm/service.go b/plugin/evm/service.go
index 7b8368e..f9b32b7 100644
--- a/plugin/evm/service.go
+++ b/plugin/evm/service.go
@@ -31,6 +31,14 @@ const (
const (
GenesisTestAddr = "0x751a0b96e1042bee789452ecb20253fba40dbe85"
GenesisTestKey = "0xabd71b35d559563fea757f0f5edbde286fb8c043105b15abb7cd57189306d7d1"
+
+ // Max number of addresses that can be passed in as argument to GetUTXOs
+ maxGetUTXOsAddrs = 1024
+)
+
+var (
+ errNoAddresses = errors.New("no addresses provided")
+ errNoSourceChain = errors.New("no source chain provided")
)
// SnowmanAPI introduces snowman specific functionality to the evm
@@ -295,3 +303,159 @@ func (service *AvaxAPI) Export(_ *http.Request, args *ExportArgs, response *api.
response.TxID = tx.ID()
return service.vm.issueTx(tx)
}
+
+// Index is an address and an associated UTXO.
+// Marks a starting or stopping point when fetching UTXOs. Used for pagination.
+type Index struct {
+ Address string `json:"address"` // The address as a string
+ UTXO string `json:"utxo"` // The UTXO ID as a string
+}
+
+// GetUTXOsArgs are arguments for passing into GetUTXOs.
+// Gets the UTXOs that reference at least one address in [Addresses].
+// Returns at most [limit] addresses.
+// If specified, [SourceChain] is the chain where the atomic UTXOs were exported from. If not specified,
+// then GetUTXOs returns an error since the C Chain only has atomic UTXOs.
+// If [limit] == 0 or > [maxUTXOsToFetch], fetches up to [maxUTXOsToFetch].
+// [StartIndex] defines where to start fetching UTXOs (for pagination.)
+// UTXOs fetched are from addresses equal to or greater than [StartIndex.Address]
+// For address [StartIndex.Address], only UTXOs with IDs greater than [StartIndex.UTXO] will be returned.
+// If [StartIndex] is omitted, gets all UTXOs.
+// If GetUTXOs is called multiple times, with our without [StartIndex], it is not guaranteed
+// that returned UTXOs are unique. That is, the same UTXO may appear in the response of multiple calls.
+type GetUTXOsArgs struct {
+ Addresses []string `json:"addresses"`
+ SourceChain string `json:"sourceChain"`
+ Limit json.Uint32 `json:"limit"`
+ StartIndex Index `json:"startIndex"`
+ Encoding string `json:"encoding"`
+}
+
+// GetUTXOsReply defines the GetUTXOs replies returned from the API
+type GetUTXOsReply struct {
+ // Number of UTXOs returned
+ NumFetched json.Uint64 `json:"numFetched"`
+ // The UTXOs
+ UTXOs []string `json:"utxos"`
+ // The last UTXO that was returned, and the address it corresponds to.
+ // Used for pagination. To get the rest of the UTXOs, call GetUTXOs
+ // again and set [StartIndex] to this value.
+ EndIndex Index `json:"endIndex"`
+ // Encoding specifies the encoding format the UTXOs are returned in
+ Encoding string `json:"encoding"`
+}
+
+// GetUTXOs gets all utxos for passed in addresses
+func (service *AvaxAPI) GetUTXOs(r *http.Request, args *GetUTXOsArgs, reply *GetUTXOsReply) error {
+ service.vm.ctx.Log.Info("EVM: GetUTXOs called for with %s", args.Addresses)
+
+ if len(args.Addresses) == 0 {
+ return errNoAddresses
+ }
+ if len(args.Addresses) > maxGetUTXOsAddrs {
+ return fmt.Errorf("number of addresses given, %d, exceeds maximum, %d", len(args.Addresses), maxGetUTXOsAddrs)
+ }
+
+ encoding, err := service.vm.encodingManager.GetEncoding(args.Encoding)
+ if err != nil {
+ return fmt.Errorf("problem getting encoding formatter for '%s': %w", args.Encoding, err)
+ }
+
+ sourceChain := ids.ID{}
+ if args.SourceChain == "" {
+ return errNoSourceChain
+ }
+
+ chainID, err := service.vm.ctx.BCLookup.Lookup(args.SourceChain)
+ if err != nil {
+ return fmt.Errorf("problem parsing source chainID %q: %w", args.SourceChain, err)
+ }
+ sourceChain = chainID
+
+ addrSet := ids.ShortSet{}
+ for _, addrStr := range args.Addresses {
+ addr, err := service.vm.ParseLocalAddress(addrStr)
+ if err != nil {
+ return fmt.Errorf("couldn't parse address %q: %w", addrStr, err)
+ }
+ addrSet.Add(addr)
+ }
+
+ startAddr := ids.ShortEmpty
+ startUTXO := ids.Empty
+ if args.StartIndex.Address != "" || args.StartIndex.UTXO != "" {
+ startAddr, err = service.vm.ParseLocalAddress(args.StartIndex.Address)
+ if err != nil {
+ return fmt.Errorf("couldn't parse start index address %q: %w", args.StartIndex.Address, err)
+ }
+ startUTXO, err = ids.FromString(args.StartIndex.UTXO)
+ if err != nil {
+ return fmt.Errorf("couldn't parse start index utxo: %w", err)
+ }
+ }
+
+ utxos, endAddr, endUTXOID, err := service.vm.GetAtomicUTXOs(
+ sourceChain,
+ addrSet,
+ startAddr,
+ startUTXO,
+ int(args.Limit),
+ )
+ if err != nil {
+ return fmt.Errorf("problem retrieving UTXOs: %w", err)
+ }
+
+ reply.UTXOs = make([]string, len(utxos))
+ for i, utxo := range utxos {
+ b, err := service.vm.codec.Marshal(utxo)
+ if err != nil {
+ return fmt.Errorf("problem marshalling UTXO: %w", err)
+ }
+ reply.UTXOs[i] = encoding.ConvertBytes(b)
+ }
+
+ endAddress, err := service.vm.FormatLocalAddress(endAddr)
+ if err != nil {
+ return fmt.Errorf("problem formatting address: %w", err)
+ }
+
+ reply.EndIndex.Address = endAddress
+ reply.EndIndex.UTXO = endUTXOID.String()
+ reply.NumFetched = json.Uint64(len(utxos))
+ reply.Encoding = encoding.Encoding()
+ return nil
+}
+
+// IssueTx ...
+func (service *AvaxAPI) IssueTx(r *http.Request, args *api.FormattedTx, response *api.JSONTxID) error {
+ log.Info("EVM: IssueTx called")
+
+ encoding, err := service.vm.encodingManager.GetEncoding(args.Encoding)
+ if err != nil {
+ return fmt.Errorf("problem getting encoding formatter for '%s': %w", args.Encoding, err)
+ }
+ txBytes, err := encoding.ConvertString(args.Tx)
+ if err != nil {
+ return fmt.Errorf("problem decoding transaction: %w", err)
+ }
+
+ tx := &Tx{}
+ if err := service.vm.codec.Unmarshal(txBytes, tx); err != nil {
+ return fmt.Errorf("problem parsing transaction: %w", err)
+ }
+ if err := tx.Sign(service.vm.codec, nil); err != nil {
+ return fmt.Errorf("problem initializing transaction: %w", err)
+ }
+
+ utx, ok := tx.UnsignedTx.(UnsignedAtomicTx)
+ if !ok {
+ return errors.New("cannot issue non-atomic transaction through IssueTx API")
+ }
+
+ if err := utx.SemanticVerify(service.vm, tx); err != nil {
+ return err
+ }
+
+ response.TxID = tx.ID()
+ return service.vm.issueTx(tx)
+}
diff --git a/plugin/evm/tx.go b/plugin/evm/tx.go
index 7c2ebf1..2d722a5 100644
--- a/plugin/evm/tx.go
+++ b/plugin/evm/tx.go
@@ -117,7 +117,7 @@ func (tx *Tx) Sign(c codec.Codec, signers [][]*crypto.PrivateKeySECP256K1R) erro
signedBytes, err := c.Marshal(tx)
if err != nil {
- return fmt.Errorf("couldn't marshal ProposalTx: %w", err)
+ return fmt.Errorf("couldn't marshal Tx: %w", err)
}
tx.Initialize(unsignedBytes, signedBytes)
return nil
diff --git a/plugin/evm/vm.go b/plugin/evm/vm.go
index a8c4fc0..fd177a0 100644
--- a/plugin/evm/vm.go
+++ b/plugin/evm/vm.go
@@ -155,7 +155,8 @@ func init() {
type VM struct {
ctx *snow.Context
- CLIConfig CommandLineConfig
+ CLIConfig CommandLineConfig
+ encodingManager formatting.EncodingManager
chainID *big.Int
networkID uint64
@@ -236,6 +237,12 @@ func (vm *VM) Initialize(
return vm.CLIConfig.ParsingError
}
+ encodingManager, err := formatting.NewEncodingManager(formatting.CB58Encoding)
+ if err != nil {
+ return fmt.Errorf("problem creating encoding manager: %w", err)
+ }
+ vm.encodingManager = encodingManager
+
if len(fxs) > 0 {
return errUnsupportedFXs
}
@@ -243,8 +250,7 @@ func (vm *VM) Initialize(
vm.ctx = ctx
vm.chaindb = Database{db}
g := new(core.Genesis)
- err := json.Unmarshal(b, g)
- if err != nil {
+ if err := json.Unmarshal(b, g); err != nil {
return err
}
@@ -947,6 +953,35 @@ func (vm *VM) GetAcceptedNonce(address common.Address) (uint64, error) {
return state.GetNonce(address), nil
}
+// ParseLocalAddress takes in an address for this chain and produces the ID
+func (vm *VM) ParseLocalAddress(addrStr string) (ids.ShortID, error) {
+ chainID, addr, err := vm.ParseAddress(addrStr)
+ if err != nil {
+ return ids.ShortID{}, err
+ }
+ if !chainID.Equals(vm.ctx.ChainID) {
+ return ids.ShortID{}, fmt.Errorf("expected chainID to be %q but was %q",
+ vm.ctx.ChainID, chainID)
+ }
+ return addr, nil
+}
+
+// FormatLocalAddress takes in a raw address and produces the formatted address
+func (vm *VM) FormatLocalAddress(addr ids.ShortID) (string, error) {
+ return vm.FormatAddress(vm.ctx.ChainID, addr)
+}
+
+// FormatAddress takes in a chainID and a raw address and produces the formatted
+// address
+func (vm *VM) FormatAddress(chainID ids.ID, addr ids.ShortID) (string, error) {
+ chainIDAlias, err := vm.ctx.BCLookup.PrimaryAlias(chainID)
+ if err != nil {
+ return "", err
+ }
+ hrp := constants.GetHRP(vm.ctx.NetworkID)
+ return formatting.FormatAddress(chainIDAlias, hrp, addr.Bytes())
+}
+
// ParseEthAddress parses [addrStr] and returns an Ethereum address
func ParseEthAddress(addrStr string) (common.Address, error) {
if !common.IsHexAddress(addrStr) {