aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorAaron Buchwald <[email protected]>2020-11-03 20:11:42 -0500
committerAaron Buchwald <[email protected]>2020-11-04 14:27:31 -0500
commit3a887bbc7b7d88070dbcdb1104119bce282ed249 (patch)
tree1adf2f3f8bdaafd4c3fae12524d5ba94db8440f3
parentd46b49cc7a0c624cb29eb40016d956d10e100ec9 (diff)
Add getUTXOs and issueTx
-rw-r--r--plugin/evm/service.go164
-rw-r--r--plugin/evm/tx.go2
2 files changed, 165 insertions, 1 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