Merge branch 'master' into illia-malachyn/752-get-execution-result-by…

…-id-endpoint
onflow · Sep 18, 2024 · b87f9c7 · b87f9c7
2 parents 6d6a330 + 3048f51
commit b87f9c7
Show file tree

Hide file tree

Showing 8 changed files with 471 additions and 4 deletions.
diff --git a/access/grpc/client.go b/access/grpc/client.go
@@ -173,10 +173,18 @@ func (c *Client) GetTransaction(ctx context.Context, txID flow.Identifier) (*flo
 	return c.grpc.GetTransaction(ctx, txID)
 }
 
+func (c *Client) GetSystemTransaction(ctx context.Context, blockID flow.Identifier) (*flow.Transaction, error) {
+	return c.grpc.GetSystemTransaction(ctx, blockID)
+}
+
 func (c *Client) GetTransactionsByBlockID(ctx context.Context, blockID flow.Identifier) ([]*flow.Transaction, error) {
 	return c.grpc.GetTransactionsByBlockID(ctx, blockID)
 }
 
+func (c *Client) GetSystemTransactionResult(ctx context.Context, blockID flow.Identifier) (*flow.TransactionResult, error) {
+	return c.grpc.GetSystemTransactionResult(ctx, blockID)
+}
+
 func (c *Client) GetTransactionResult(ctx context.Context, txID flow.Identifier) (*flow.TransactionResult, error) {
 	return c.grpc.GetTransactionResult(ctx, txID)
 }
@@ -200,6 +208,14 @@ func (c *Client) GetAccountAtBlockHeight(ctx context.Context, address flow.Addre
 	return c.grpc.GetAccountAtBlockHeight(ctx, address, blockHeight)
 }
 
+func (c *Client) GetAccountBalanceAtLatestBlock(ctx context.Context, address flow.Address) (uint64, error) {
+	return c.grpc.GetAccountBalanceAtLatestBlock(ctx, address)
+}
+
+func (c *Client) GetAccountBalanceAtBlockHeight(ctx context.Context, address flow.Address, blockHeight uint64) (uint64, error) {
+	return c.grpc.GetAccountBalanceAtBlockHeight(ctx, address, blockHeight)
+}
+
 func (c *Client) ExecuteScriptAtLatestBlock(ctx context.Context, script []byte, arguments []cadence.Value) (cadence.Value, error) {
 	return c.grpc.ExecuteScriptAtLatestBlock(ctx, script, arguments)
 }

diff --git a/access/grpc/grpc.go b/access/grpc/grpc.go
@@ -362,6 +362,28 @@ func (c *BaseClient) GetTransaction(
 	return &result, nil
 }
 
+func (c *BaseClient) GetSystemTransaction(
+	ctx context.Context,
+	blockID flow.Identifier,
+	opts ...grpc.CallOption,
+) (*flow.Transaction, error) {
+	req := &access.GetSystemTransactionRequest{
+		BlockId: blockID.Bytes(),
+	}
+
+	res, err := c.rpcClient.GetSystemTransaction(ctx, req, opts...)
+	if err != nil {
+		return nil, newRPCError(err)
+	}
+
+	result, err := convert.MessageToTransaction(res.GetTransaction())
+	if err != nil {
+		return nil, newMessageToEntityError(entityTransaction, err)
+	}
+
+	return &result, nil
+}
+
 func (c *BaseClient) GetTransactionsByBlockID(
 	ctx context.Context,
 	blockID flow.Identifier,
@@ -389,6 +411,29 @@ func (c *BaseClient) GetTransactionsByBlockID(
 	return results, nil
 }
 
+func (c *BaseClient) GetSystemTransactionResult(
+	ctx context.Context,
+	blockID flow.Identifier,
+	opts ...grpc.CallOption,
+) (*flow.TransactionResult, error) {
+	req := &access.GetSystemTransactionResultRequest{
+		BlockId:              blockID.Bytes(),
+		EventEncodingVersion: c.eventEncoding,
+	}
+
+	res, err := c.rpcClient.GetSystemTransactionResult(ctx, req, opts...)
+	if err != nil {
+		return nil, newRPCError(err)
+	}
+
+	result, err := convert.MessageToTransactionResult(res, c.jsonOptions)
+	if err != nil {
+		return nil, newMessageToEntityError(entityTransactionResult, err)
+	}
+
+	return &result, nil
+}
+
 func (c *BaseClient) GetTransactionResult(
 	ctx context.Context,
 	txID flow.Identifier,
@@ -516,6 +561,42 @@ func (c *BaseClient) GetAccountAtBlockHeight(
 	return &account, nil
 }
 
+func (c *BaseClient) GetAccountBalanceAtLatestBlock(
+	ctx context.Context,
+	address flow.Address,
+	opts ...grpc.CallOption,
+) (uint64, error) {
+	request := &access.GetAccountBalanceAtLatestBlockRequest{
+		Address: address.Bytes(),
+	}
+
+	response, err := c.rpcClient.GetAccountBalanceAtLatestBlock(ctx, request, opts...)
+	if err != nil {
+		return 0, newRPCError(err)
+	}
+
+	return response.GetBalance(), nil
+}
+
+func (c *BaseClient) GetAccountBalanceAtBlockHeight(
+	ctx context.Context,
+	address flow.Address,
+	blockHeight uint64,
+	opts ...grpc.CallOption,
+) (uint64, error) {
+	request := &access.GetAccountBalanceAtBlockHeightRequest{
+		Address:     address.Bytes(),
+		BlockHeight: blockHeight,
+	}
+
+	response, err := c.rpcClient.GetAccountBalanceAtBlockHeight(ctx, request, opts...)
+	if err != nil {
+		return 0, newRPCError(err)
+	}
+
+	return response.GetBalance(), nil
+}
+
 func (c *BaseClient) ExecuteScriptAtLatestBlock(
 	ctx context.Context,
 	script []byte,

diff --git a/access/grpc/grpc_test.go b/access/grpc/grpc_test.go
@@ -445,6 +445,42 @@ func TestClient_SendTransaction(t *testing.T) {
 	}))
 }
 
+func TestClient_GetSystemTransaction(t *testing.T) {
+	txs := test.TransactionGenerator()
+	ids := test.IdentifierGenerator()
+
+	t.Run("Success", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		blockID := ids.New()
+		expectedTx := txs.New()
+
+		txMsg, err := convert.TransactionToMessage(*expectedTx)
+		require.NoError(t, err)
+
+		response := &access.TransactionResponse{
+			Transaction: txMsg,
+		}
+
+		rpc.On("GetSystemTransaction", ctx, mock.Anything).Return(response, nil)
+
+		tx, err := c.GetSystemTransaction(ctx, blockID)
+		require.NoError(t, err)
+
+		assert.Equal(t, expectedTx, tx)
+	}))
+
+	t.Run("Not found error", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		blockID := ids.New()
+
+		rpc.On("GetSystemTransaction", ctx, mock.Anything).
+			Return(nil, errNotFound)
+
+		tx, err := c.GetSystemTransaction(ctx, blockID)
+		assert.Error(t, err)
+		assert.Equal(t, codes.NotFound, status.Code(err))
+		assert.Nil(t, tx)
+	}))
+}
+
 func TestClient_GetTransaction(t *testing.T) {
 	txs := test.TransactionGenerator()
 	ids := test.IdentifierGenerator()
@@ -516,6 +552,62 @@ func TestClient_GetTransactionsByBlockID(t *testing.T) {
 	}))
 }
 
+func TestClient_GetSystemTransactionResult(t *testing.T) {
+	ids := test.IdentifierGenerator()
+
+	t.Run("Success", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		results := test.TransactionResultGenerator(flow.EventEncodingVersionCCF)
+		blockID := ids.New()
+		expectedResult := results.New()
+		response, _ := convert.TransactionResultToMessage(expectedResult, flow.EventEncodingVersionCCF)
+
+		rpc.On("GetSystemTransactionResult", ctx, mock.Anything).Return(response, nil)
+
+		result, err := c.GetSystemTransactionResult(ctx, blockID)
+		require.NoError(t, err)
+
+		// Force evaluation of type ID, which is cached in type.
+		// Necessary for equality check below
+		for _, event := range result.Events {
+			_ = event.Value.Type().ID()
+		}
+
+		assert.Equal(t, expectedResult, *result)
+	}))
+
+	t.Run("Success with jsoncdc", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		results := test.TransactionResultGenerator(flow.EventEncodingVersionJSONCDC)
+		blockID := ids.New()
+		expectedResult := results.New()
+		response, _ := convert.TransactionResultToMessage(expectedResult, flow.EventEncodingVersionJSONCDC)
+
+		rpc.On("GetSystemTransactionResult", ctx, mock.Anything).Return(response, nil)
+
+		result, err := c.GetSystemTransactionResult(ctx, blockID)
+		require.NoError(t, err)
+
+		// Force evaluation of type ID, which is cached in type.
+		// Necessary for equality check below
+		for _, event := range result.Events {
+			_ = event.Value.Type().ID()
+		}
+
+		assert.Equal(t, expectedResult, *result)
+	}))
+
+	t.Run("Not found error", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		blockID := ids.New()
+
+		rpc.On("GetSystemTransactionResult", ctx, mock.Anything).
+			Return(nil, errNotFound)
+
+		result, err := c.GetSystemTransactionResult(ctx, blockID)
+		assert.Error(t, err)
+		assert.Equal(t, codes.NotFound, status.Code(err))
+		assert.Nil(t, result)
+	}))
+}
+
 func TestClient_GetTransactionResult(t *testing.T) {
 	ids := test.IdentifierGenerator()
 
@@ -709,6 +801,73 @@ func TestClient_GetAccountAtBlockHeight(t *testing.T) {
 	}))
 }
 
+func TestClient_GetAccountBalanceAtLatestBlock(t *testing.T) {
+	accounts := test.AccountGenerator()
+	addresses := test.AddressGenerator()
+
+	t.Run("Success", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		account := accounts.New()
+
+		response := &access.AccountBalanceResponse{
+			Balance: account.Balance,
+		}
+
+		rpc.On("GetAccountBalanceAtLatestBlock", ctx, mock.Anything).Return(response, nil)
+
+		balance, err := c.GetAccountBalanceAtLatestBlock(ctx, account.Address)
+		require.NoError(t, err)
+
+		assert.Equal(t, account.Balance, balance)
+
+	}))
+
+	t.Run("Not found error", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		address := addresses.New()
+
+		rpc.On("GetAccountBalanceAtLatestBlock", ctx, mock.Anything).
+			Return(nil, errNotFound)
+
+		balance, err := c.GetAccountBalanceAtLatestBlock(ctx, address)
+		assert.Error(t, err)
+		assert.Equal(t, codes.NotFound, status.Code(err))
+		assert.Equal(t, balance, uint64(0))
+	}))
+}
+
+func TestClient_GetAccountBalanceAtBlockHeight(t *testing.T) {
+	accounts := test.AccountGenerator()
+	addresses := test.AddressGenerator()
+	blockHeight := uint64(42)
+
+	t.Run("Success", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		account := accounts.New()
+
+		response := &access.AccountBalanceResponse{
+			Balance: account.Balance,
+		}
+
+		rpc.On("GetAccountBalanceAtBlockHeight", ctx, mock.Anything).Return(response, nil)
+
+		balance, err := c.GetAccountBalanceAtBlockHeight(ctx, account.Address, blockHeight)
+		require.NoError(t, err)
+
+		assert.Equal(t, account.Balance, balance)
+
+	}))
+
+	t.Run("Not found error", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
+		address := addresses.New()
+
+		rpc.On("GetAccountBalanceAtBlockHeight", ctx, mock.Anything).
+			Return(nil, errNotFound)
+
+		balance, err := c.GetAccountBalanceAtBlockHeight(ctx, address, blockHeight)
+		assert.Error(t, err)
+		assert.Equal(t, codes.NotFound, status.Code(err))
+		assert.Equal(t, balance, uint64(0))
+	}))
+}
+
 func TestClient_ExecuteScriptAtLatestBlock(t *testing.T) {
 	t.Run("Success", clientTest(func(t *testing.T, ctx context.Context, rpc *mocks.MockRPCClient, c *BaseClient) {
 		expectedValue := cadence.NewInt(42)