mleku/sui-go-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #1 from bvcrypto/main

Browse Source 
Remove deprecated methods
This commit is contained in:
bvcrypto
2023-01-17 12:00:21 +08:00
committed by GitHub
parent 3c3bd27f1f 18dccaba88
commit 0ecf4f72b8
4 changed files with 48 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
models/read_event.go
View File

@@ -2,66 +2,13 @@ package models
import "github.com/block-vision/sui-go-sdk/models/sui_json_rpc_types"
type GetEventsByEventTypeRequest struct {
EventType string `json:"eventType"`
Count uint64 `json:"count"`
StartTime uint64 `json:"startTime"`
EndTime uint64 `json:"endTime"`
type GetEventsRequest struct {
EventQuery interface{}
Cursor *string
Limit uint64
DescOrder bool
}
type GetEventsByEventTypeResponse struct {
Result []sui_json_rpc_types.SuiEventEnvelop
}
type GetEventsByModuleRequest struct {
Package string `json:"package"`
Module string `json:"module"`
Count uint64 `json:"count"`
StartTime uint64 `json:"startTime"`
EndTime uint64 `json:"endTime"`
}
type GetEventsByModuleResponse struct {
Result []sui_json_rpc_types.SuiEventEnvelop
}
type GetEventsByObjectRequest struct {
Object string `json:"object"`
Count uint64 `json:"count"`
StartTime uint64 `json:"startTime"`
EndTime uint64 `json:"endTime"`
}
type GetEventsByObjectResponse struct {
Result []sui_json_rpc_types.SuiEventEnvelop
}
type GetEventsByOwnerRequest struct {
Owner string `json:"owner"`
Count uint64 `json:"count"`
StartTime uint64 `json:"startTime"`
EndTime uint64 `json:"endTime"`
}
type GetEventsByOwnerResponse struct {
Result []sui_json_rpc_types.SuiEventEnvelop
}
type GetEventsBySenderRequest struct {
Sender string `json:"sender"`
Count uint64 `json:"count"`
StartTime uint64 `json:"startTime"`
EndTime uint64 `json:"endTime"`
}
type GetEventsBySenderResponse struct {
Result []sui_json_rpc_types.SuiEventEnvelop
}
type GetEventsByTransactionRequest struct {
Digest string `json:"digest"`
}
type GetEventsByTransactionResponse struct {
type GetEventsResponse struct {
Result []sui_json_rpc_types.SuiEventEnvelop
}

6
models/sui_json_rpc_types/lib.go
View File

@@ -136,9 +136,9 @@ type SuiObjectInfo struct {
}
type SuiEventEnvelop struct {
Timestamp uint64 `json:"timestamp"`
TxDigest string `json:"txDigest,omitempty"`
SuiEvent
Timestamp uint64 `json:"timestamp"`
TxDigest string `json:"txDigest,omitempty"`
SuiEvent SuiEvent `json:"event"`
}
type SuiMoveModuleId struct {

26
sui/api_test.go Normal file
View File

@@ -0,0 +1,26 @@
package sui
import (
"context"
"fmt"
"testing"
"github.com/block-vision/sui-go-sdk/models"
)
func TestOnAPIs(t *testing.T) {
t.Run("test on sui_getEvents", func(t *testing.T) {
cli := NewSuiClient("https://fullnode.devnet.sui.io/")
resp, err := cli.GetEvents(context.Background(), models.GetEventsRequest{
EventQuery: "All",
Cursor: nil,
Limit: 1,
DescOrder: true,
})
if err != nil {
fmt.Println(err.Error())
t.FailNow()
}
fmt.Printf("%+v", resp)
})
}

159
sui/read_event_api.go
View File

@@ -11,168 +11,35 @@ import (
)
type IReadEventFromSuiAPI interface {
GetEventsByEventType(ctx context.Context, req models.GetEventsByEventTypeRequest, opts ...interface{}) (models.GetEventsByEventTypeResponse, error)
GetEventsByModule(ctx context.Context, req models.GetEventsByModuleRequest, opts ...interface{}) (models.GetEventsByModuleResponse, error)
GetEventsByObject(ctx context.Context, req models.GetEventsByObjectRequest, opts ...interface{}) (models.GetEventsByObjectResponse, error)
GetEventsByOwner(ctx context.Context, req models.GetEventsByOwnerRequest, opts ...interface{}) (models.GetEventsByOwnerResponse, error)
GetEventsBySender(ctx context.Context, req models.GetEventsBySenderRequest, opts ...interface{}) (models.GetEventsBySenderResponse, error)
GetEventsByTransaction(ctx context.Context, req models.GetEventsByTransactionRequest, opts ...interface{}) (models.GetEventsByTransactionResponse, error)
GetEvents(ctx context.Context, req models.GetEventsRequest, opts ...interface{}) (models.GetEventsResponse, error)
}
type suiReadEventFromSuiImpl struct {
cli *rpc_client.RPCClient
}
// GetEventsByEventType implements method `sui_getEventsByEventType`.
// GetEventsBy implements method `sui_getEvents`.
// Returns an array of EventEnvelops according to your filter request condition.
func (s *suiReadEventFromSuiImpl) GetEventsByEventType(ctx context.Context, req models.GetEventsByEventTypeRequest, opts ...interface{}) (models.GetEventsByEventTypeResponse, error) {
var rsp models.GetEventsByEventTypeResponse
func (s *suiReadEventFromSuiImpl) GetEvents(ctx context.Context, req models.GetEventsRequest, opts ...interface{}) (models.GetEventsResponse, error) {
var rsp models.GetEventsResponse
respBytes, err := s.cli.Request(ctx, models.Operation{
Method: "sui_getEventsByEventType",
Method: "sui_getEvents",
Params: []interface{}{
req.EventType,
req.Count,
req.StartTime,
req.EndTime,
req.EventQuery,
req.Cursor,
req.Limit,
req.DescOrder,
},
})
if err != nil {
return models.GetEventsByEventTypeResponse{}, err
return models.GetEventsResponse{}, err
}
if gjson.ParseBytes(respBytes).Get("error").Exists() {
return models.GetEventsByEventTypeResponse{}, errors.New(gjson.ParseBytes(respBytes).Get("error").String())
return models.GetEventsResponse{}, errors.New(gjson.ParseBytes(respBytes).Get("error").String())
}
err = json.Unmarshal([]byte(gjson.ParseBytes(respBytes).Get("result").String()), &rsp.Result)
err = json.Unmarshal([]byte(gjson.ParseBytes(respBytes).Get("result.data").String()), &rsp.Result)
if err != nil {
return models.GetEventsByEventTypeResponse{}, err
}
return rsp, nil
}
// GetEventsByModule implements method `sui_getEventsByModule`.
// Returns an array of EventEnvelops according to your filter request condition
func (s *suiReadEventFromSuiImpl) GetEventsByModule(ctx context.Context, req models.GetEventsByModuleRequest, opts ...interface{}) (models.GetEventsByModuleResponse, error) {
var rsp models.GetEventsByModuleResponse
respBytes, err := s.cli.Request(ctx, models.Operation{
Method: "sui_getEventsByModule",
Params: []interface{}{
req.Package,
req.Module,
req.Count,
req.StartTime,
req.EndTime,
},
})
if err != nil {
return models.GetEventsByModuleResponse{}, err
}
if gjson.ParseBytes(respBytes).Get("error").Exists() {
return models.GetEventsByModuleResponse{}, errors.New(gjson.ParseBytes(respBytes).Get("error").String())
}
err = json.Unmarshal([]byte(gjson.ParseBytes(respBytes).Get("result").String()), &rsp.Result)
if err != nil {
return models.GetEventsByModuleResponse{}, err
}
return rsp, nil
}
// GetEventsByObject implements method `sui_getEventsByObject`.
// Returns an array of EventEnvelops according to your filter request condition
func (s *suiReadEventFromSuiImpl) GetEventsByObject(ctx context.Context, req models.GetEventsByObjectRequest, opts ...interface{}) (models.GetEventsByObjectResponse, error) {
var rsp models.GetEventsByObjectResponse
respBytes, err := s.cli.Request(ctx, models.Operation{
Method: "sui_getEventsByObject",
Params: []interface{}{
req.Object,
req.Count,
req.StartTime,
req.EndTime,
},
})
if err != nil {
return models.GetEventsByObjectResponse{}, err
}
if gjson.ParseBytes(respBytes).Get("error").Exists() {
return models.GetEventsByObjectResponse{}, errors.New(gjson.ParseBytes(respBytes).Get("error").String())
}
err = json.Unmarshal([]byte(gjson.ParseBytes(respBytes).Get("result").String()), &rsp.Result)
if err != nil {
return models.GetEventsByObjectResponse{}, err
}
return rsp, nil
}
// GetEventsByOwner implements method `sui_getEventsByOwner`.
// Returns an array of EventEnvelops according to your filter request condition
func (s *suiReadEventFromSuiImpl) GetEventsByOwner(ctx context.Context, req models.GetEventsByOwnerRequest, opts ...interface{}) (models.GetEventsByOwnerResponse, error) {
var rsp models.GetEventsByOwnerResponse
respBytes, err := s.cli.Request(ctx, models.Operation{
Method: "sui_getEventsByOwner",
Params: []interface{}{
req.Owner,
req.Count,
req.StartTime,
req.EndTime,
},
})
if err != nil {
return models.GetEventsByOwnerResponse{}, err
}
if gjson.ParseBytes(respBytes).Get("error").Exists() {
return models.GetEventsByOwnerResponse{}, errors.New(gjson.ParseBytes(respBytes).Get("error").String())
}
err = json.Unmarshal([]byte(gjson.ParseBytes(respBytes).Get("result").String()), &rsp.Result)
if err != nil {
return models.GetEventsByOwnerResponse{}, err
}
return rsp, nil
}
// GetEventsBySender implements method `sui_getEventsBySender`.
// Returns an array of EventEnvelops according to your filter request condition
func (s *suiReadEventFromSuiImpl) GetEventsBySender(ctx context.Context, req models.GetEventsBySenderRequest, opts ...interface{}) (models.GetEventsBySenderResponse, error) {
var rsp models.GetEventsBySenderResponse
respBytes, err := s.cli.Request(ctx, models.Operation{
Method: "sui_getEventsBySender",
Params: []interface{}{
req.Sender,
req.Count,
req.StartTime,
req.EndTime,
},
})
if err != nil {
return models.GetEventsBySenderResponse{}, err
}
if gjson.ParseBytes(respBytes).Get("error").Exists() {
return models.GetEventsBySenderResponse{}, errors.New(gjson.ParseBytes(respBytes).Get("error").String())
}
err = json.Unmarshal([]byte(gjson.ParseBytes(respBytes).Get("result").String()), &rsp.Result)
if err != nil {
return models.GetEventsBySenderResponse{}, err
}
return rsp, nil
}
// GetEventsByTransaction implements method `sui_getEventsByTransaction`.
// Returns an array of EventEnvelops according to your filter request condition
func (s *suiReadEventFromSuiImpl) GetEventsByTransaction(ctx context.Context, req models.GetEventsByTransactionRequest, opts ...interface{}) (models.GetEventsByTransactionResponse, error) {
var rsp models.GetEventsByTransactionResponse
respBytes, err := s.cli.Request(ctx, models.Operation{
Method: "sui_getEventsByTransaction",
Params: []interface{}{
req.Digest,
},
})
if err != nil {
return models.GetEventsByTransactionResponse{}, err
}
if gjson.ParseBytes(respBytes).Get("error").Exists() {
return models.GetEventsByTransactionResponse{}, errors.New(gjson.ParseBytes(respBytes).Get("error").String())
}
err = json.Unmarshal([]byte(gjson.ParseBytes(respBytes).Get("result").String()), &rsp.Result)
if err != nil {
return models.GetEventsByTransactionResponse{}, err
return models.GetEventsResponse{}, err
}
return rsp, nil
}