Merge branch 'main' into improve-account-behavior

Author: gregnazario

CHANGELOG.md

@@ -5,6 +5,8 @@ adheres to the format set out by [Keep a Changelog](https://keepachangelog.com/e
 
 # Unreleased
 
+- [`Fix`] Ensure proper cleanup of response body on read error to prevent potential memory leak.
+
 # v1.5.0 (2/10/2024)
 
 - [`Fix`] Make NodeClient match AptosRpcClient interface

bcs/deserializer.go

@@ -318,3 +318,8 @@ func (des *Deserializer) setError(msg string, args ...any) {
 	}
 	des.err = fmt.Errorf(msg, args...)
 }
+
+// DeserializeBytes deserializes a byte array prefixed with a length
+func (des *Deserializer) Serialized() *Serialized {
+	return &Serialized{des.ReadBytes()}
+}

bcs/serialized.go

@@ -0,0 +1,29 @@
+package bcs
+
+// Serialized represents a serialized transaction argument
+type Serialized struct {
+	Value []byte
+}
+
+// NewSerialized creates a new Serialized instance
+func NewSerialized(value []byte) *Serialized {
+	return &Serialized{
+		Value: value,
+	}
+}
+
+// Serialize serializes the Serialized instance
+func (s *Serialized) Serialized(serializer *Serializer) {
+	serializer.WriteBytes(s.Value)
+}
+
+// SerializeForEntryFunction serializes the Serialized instance for entry function
+func (s *Serialized) SerializedForEntryFunction(serializer *Serializer) {
+	s.Serialized(serializer)
+}
+
+// SerializeForScriptFunction serializes the Serialized instance for script function
+func (s *Serialized) SerializedForScriptFunction(serializer *Serializer) {
+	serializer.Uleb128(uint32(9))
+	s.Serialized(serializer)
+}

bcs/serializer.go

@@ -352,3 +352,16 @@ func SerializeOption[T any](ser *Serializer, input *T, serialize func(ser *Seria
 		SerializeSequenceWithFunction([]T{*input}, ser, serialize)
 	}
 }
+
+// Serialized wraps already serialized bytes with BCS serialization
+// It prepends the byte array with its length (encoded as Uleb128) and writes the bytes
+// Primarily used for handling nested serialization structures where bytes are already in BCS format
+func (ser *Serializer) Serialized(s Serialized) {
+	ser.WriteBytes(s.Value)
+}
+
+func SerializeSerialized(input Serialized) ([]byte, error) {
+	return SerializeSingle(func(ser *Serializer) {
+		ser.Serialized(input)
+	})
+}

client.go

@@ -217,6 +217,22 @@ type AptosRpcClient interface {
 	//	client.AccountTransactions(AccountOne, 1, 100) // Returns 100 transactions for 0x1
 	AccountTransactions(address AccountAddress, start *uint64, limit *uint64) (data []*api.CommittedTransaction, err error)
 
+	// EventsByHandle retrieves events by event handle and field name for a given account.
+	//
+	// Arguments:
+	//   - account - The account address to get events for
+	//   - eventHandle - The event handle struct tag
+	//   - fieldName - The field in the event handle struct
+	//   - start - The starting sequence number. nil for most recent events
+	//   - limit - The number of events to return, 100 by default
+	EventsByHandle(
+		account AccountAddress,
+		eventHandle string,
+		fieldName string,
+		start *uint64,
+		limit *uint64,
+	) ([]*api.Event, error)
+
 	// SubmitTransaction Submits an already signed transaction to the blockchain
 	//
 	//	sender := NewEd25519Account()
@@ -649,6 +665,16 @@ func (client *Client) AccountTransactions(address AccountAddress, start *uint64,
 	return client.nodeClient.AccountTransactions(address, start, limit)
 }
 
+// EventsByHandle Get events by handle and field name for an account.
+// Start is a sequence number. Nil for most recent events.
+// Limit is a number of events to return, 100 by default.
+//
+//	client.EventsByHandle(AccountOne, "0x2", "transfer", 0, 2)   // Returns 2 events
+//	client.EventsByHandle(AccountOne, "0x2", "transfer", 1, 100) // Returns 100 events
+func (client *Client) EventsByHandle(account AccountAddress, eventHandle string, fieldName string, start *uint64, limit *uint64) ([]*api.Event, error) {
+	return client.nodeClient.EventsByHandle(account, eventHandle, fieldName, start, limit)
+}
+
 // SubmitTransaction Submits an already signed transaction to the blockchain
 //
 //	sender := NewEd25519Account()

examples/script_transaction/main.go

@@ -0,0 +1,107 @@
+// fungible_asset is an example of how to create and transfer fungible assets
+package main
+
+import (
+	"fmt"
+
+	"github.com/aptos-labs/aptos-go-sdk"
+	"github.com/aptos-labs/aptos-go-sdk/bcs"
+	"github.com/aptos-labs/aptos-go-sdk/crypto"
+)
+
+const testEd25519PrivateKey = "ed25519-priv-0xc5338cd251c22daa8c9c9cc94f498cc8a5c7e1d2e75287a5dda91096fe64efa5"
+
+const TransferScriptPayload = "0x008601a11ceb0b0700000a06010002030206050806070e1708252010451900000001010000010003060c05030d6170746f735f6163636f756e74087472616e736665720000000000000000000000000000000000000000000000000000000000000001166170746f733a3a7363726970745f636f6d706f7365720100000100050a000b010b0211000200020920000000000000000000000000000000000000000000000000000000000000000209086400000000000000"
+const TransferAmount = uint64(1_000)
+const FundAmount = uint64(100_000_000)
+
+func example(networkConfig aptos.NetworkConfig) {
+	// Create a client for Aptos
+	client, err := aptos.NewClient(networkConfig)
+	if err != nil {
+		panic("Failed to create client:" + err.Error())
+	}
+
+	// Create a sender locally
+	key := crypto.Ed25519PrivateKey{}
+	err = key.FromHex(testEd25519PrivateKey)
+	if err != nil {
+		panic("Failed to decode Ed25519 private key:" + err.Error())
+	}
+	sender, err := aptos.NewAccountFromSigner(&key)
+	if err != nil {
+		panic("Failed to create sender:" + err.Error())
+	}
+
+	// Fund the sender with the faucet to create it on-chain
+	println("SENDER: ", sender.Address.String())
+	err = client.Fund(sender.Address, FundAmount)
+	if err != nil {
+		panic("Failed to fund sender:" + err.Error())
+	}
+	receiver := &aptos.AccountAddress{}
+
+	// Now run a script version
+	fmt.Printf("\n== Now running script version ==\n")
+	runScript(client, sender, receiver)
+
+	if err != nil {
+		panic("Failed to get store balance:" + err.Error())
+	}
+	// fmt.Printf("After Script: Receiver Before transfer: %d, after transfer: %d\n", receiverAfterBalance, receiverAfterAfterBalance)
+}
+
+func runScript(client *aptos.Client, alice *aptos.Account, bob *aptos.AccountAddress) {
+	scriptBytes, err := aptos.ParseHex(TransferScriptPayload)
+	if err != nil {
+		panic("Failed to parse script:" + err.Error())
+	}
+
+	var payload aptos.TransactionPayload
+	payload.UnmarshalBCS(bcs.NewDeserializer(scriptBytes))
+
+	// 1. Build transaction
+	rawTxn, err := client.BuildTransaction(alice.AccountAddress(), payload)
+
+	if err != nil {
+		panic("Failed to build transaction:" + err.Error())
+	}
+
+	// 2. Simulate transaction (optional)
+	// This is useful for understanding how much the transaction will cost
+	// and to ensure that the transaction is valid before sending it to the network
+	// This is optional, but recommended
+	simulationResult, err := client.SimulateTransaction(rawTxn, alice)
+	if err != nil {
+		panic("Failed to simulate transaction:" + err.Error())
+	}
+	fmt.Printf("\n=== Simulation ===\n")
+	fmt.Printf("Gas unit price: %d\n", simulationResult[0].GasUnitPrice)
+	fmt.Printf("Gas used: %d\n", simulationResult[0].GasUsed)
+	fmt.Printf("Total gas fee: %d\n", simulationResult[0].GasUsed*simulationResult[0].GasUnitPrice)
+	fmt.Printf("Status: %s\n", simulationResult[0].VmStatus)
+
+	// 3. Sign transaction
+	signedTxn, err := rawTxn.SignedTransaction(alice)
+	if err != nil {
+		panic("Failed to sign transaction:" + err.Error())
+	}
+
+	// 4. Submit transaction
+	submitResult, err := client.SubmitTransaction(signedTxn)
+	if err != nil {
+		panic("Failed to submit transaction:" + err.Error())
+	}
+	txnHash := submitResult.Hash
+
+	// 5. Wait for the transaction to complete
+	_, err = client.WaitForTransaction(txnHash)
+	if err != nil {
+		panic("Failed to wait for transaction:" + err.Error())
+	}
+}
+
+// main This example shows how to send a transaction with a script
+func main() {
+	example(aptos.DevnetConfig)
+}

nodeClient.go

@@ -407,6 +407,91 @@ func (rc *NodeClient) AccountTransactions(account AccountAddress, start *uint64,
 	})
 }
 
+func (rc *NodeClient) EventsByHandle(
+	account AccountAddress,
+	eventHandle string,
+	fieldName string,
+	start *uint64,
+	limit *uint64,
+) (data []*api.Event, err error) {
+	basePath := fmt.Sprintf("accounts/%s/events/%s/%s",
+		account.String(),
+		eventHandle,
+		fieldName)
+
+	baseUrl := rc.baseUrl.JoinPath(basePath)
+
+	const eventsPageSize = 100
+	var effectiveLimit uint64
+	if limit == nil {
+		effectiveLimit = eventsPageSize
+	} else {
+		effectiveLimit = *limit
+	}
+
+	var effectiveStart uint64
+	if start == nil {
+		effectiveStart = 0
+	} else {
+		effectiveStart = *start
+	}
+
+	if effectiveLimit <= eventsPageSize {
+		params := url.Values{}
+		params.Set("start", strconv.FormatUint(effectiveStart, 10))
+		params.Set("limit", strconv.FormatUint(effectiveLimit, 10))
+
+		requestUrl := *baseUrl
+		requestUrl.RawQuery = params.Encode()
+
+		data, err = Get[[]*api.Event](rc, requestUrl.String())
+		if err != nil {
+			return nil, fmt.Errorf("get events api err: %w", err)
+		}
+		return data, nil
+	}
+
+	pages := (effectiveLimit + eventsPageSize - 1) / eventsPageSize
+	channels := make([]chan ConcResponse[[]*api.Event], pages)
+
+	for i := uint64(0); i < pages; i++ {
+		channels[i] = make(chan ConcResponse[[]*api.Event], 1)
+		pageStart := effectiveStart + (i * eventsPageSize)
+		pageLimit := min(eventsPageSize, effectiveLimit-(i*eventsPageSize))
+
+		go fetch(func() ([]*api.Event, error) {
+			params := url.Values{}
+			params.Set("start", strconv.FormatUint(pageStart, 10))
+			params.Set("limit", strconv.FormatUint(pageLimit, 10))
+
+			requestUrl := *baseUrl
+			requestUrl.RawQuery = params.Encode()
+
+			events, err := Get[[]*api.Event](rc, requestUrl.String())
+			if err != nil {
+				return nil, fmt.Errorf("get events api err: %w", err)
+			}
+			return events, nil
+		}, channels[i])
+	}
+
+	events := make([]*api.Event, 0, effectiveLimit)
+	for i, ch := range channels {
+		response := <-ch
+		if response.Err != nil {
+			return nil, response.Err
+		}
+		events = append(events, response.Result...)
+		close(channels[i])
+	}
+
+	sort.Slice(events, func(i, j int) bool {
+		return events[i].SequenceNumber < events[j].SequenceNumber
+	})
+
+	return events, nil
+}
+
 // handleTransactions is a helper function for fetching transactions
 //
 // It will fetch the transactions from the node in a single request if possible, otherwise it will fetch them concurrently.
@@ -1051,11 +1136,11 @@ func Get[T any](rc *NodeClient, getUrl string) (out T, err error) {
 		err = NewHttpError(response)
 		return out, err
 	}
+	defer response.Body.Close()
 	blob, err := io.ReadAll(response.Body)
 	if err != nil {
 		return out, fmt.Errorf("error getting response data, %w", err)
 	}
-	_ = response.Body.Close()
 	err = json.Unmarshal(blob, &out)
 	if err != nil {
 		return out, err
@@ -1086,12 +1171,12 @@ func (rc *NodeClient) GetBCS(getUrl string) (out []byte, err error) {
 		err = NewHttpError(response)
 		return
 	}
+	defer response.Body.Close()
 	blob, err := io.ReadAll(response.Body)
 	if err != nil {
 		err = fmt.Errorf("error getting response data, %w", err)
 		return
 	}
-	_ = response.Body.Close()
 	return blob, nil
 }
 
@@ -1121,12 +1206,12 @@ func Post[T any](rc *NodeClient, postUrl string, contentType string, body io.Rea
 		err = NewHttpError(response)
 		return data, err
 	}
+	defer response.Body.Close()
 	blob, err := io.ReadAll(response.Body)
 	if err != nil {
 		err = fmt.Errorf("error getting response data, %w", err)
 		return data, err
 	}
-	_ = response.Body.Close()
 
 	err = json.Unmarshal(blob, &data)
 	return data, err