From 6015d5be071ae6ea49b691d4a2bfcfcd359d94b0 Mon Sep 17 00:00:00 2001 From: Alexey Kostenko Date: Fri, 20 Sep 2024 16:08:04 +0300 Subject: [PATCH 1/5] liteapi request decoder --- liteclient/decoder.go | 56 ++++ liteclient/generated.go | 638 ++++++++++++++++++++++++++++++++++++++++ tl/parser/generator.go | 113 +++++-- 3 files changed, 788 insertions(+), 19 deletions(-) create mode 100644 liteclient/decoder.go diff --git a/liteclient/decoder.go b/liteclient/decoder.go new file mode 100644 index 00000000..2ebe1818 --- /dev/null +++ b/liteclient/decoder.go @@ -0,0 +1,56 @@ +package liteclient + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "github.com/tonkeeper/tongo/tl" + "reflect" +) + +func pointer[T any](t T) *T { + return &t +} + +type RequestName = string + +const ( + UnknownRequest RequestName = "Unknown" +) + +func decodeRequest(tag uint32, name RequestName, msgType any) reqDecoderFunc { + return func(b []byte) (*RequestName, any, error) { + if len(b) < 4 { + return nil, nil, errors.New("message too short") + } + readTag := binary.LittleEndian.Uint32(b[:4]) + if readTag != tag { + return nil, nil, fmt.Errorf("invalid tag") + } + body := reflect.New(reflect.TypeOf(msgType)) + reader := bytes.NewReader(b[4:]) + err := tl.Unmarshal(reader, body.Interface()) + if err == nil { + return pointer(name), body.Elem().Interface(), nil + } + return nil, nil, err + } +} + +type reqDecoderFunc func(b []byte) (*RequestName, any, error) + +func LiteapiRequestDecoder(b []byte) (*uint32, *RequestName, any, error) { + if len(b) < 4 { + return nil, nil, nil, errors.New("message too short") + } + tag := binary.LittleEndian.Uint32(b[:4]) + f := taggedRequestDecodeFunctions[tag] + if f != nil { + o, d, err := f(b) + if err == nil { + return &tag, o, d, nil + } + } + return &tag, pointer(UnknownRequest), nil, nil +} diff --git a/liteclient/generated.go b/liteclient/generated.go index c01ec3b9..54a1209a 100644 --- a/liteclient/generated.go +++ b/liteclient/generated.go @@ -2883,6 +2883,12 @@ func (t *LiteServerDebugVerbosityC) UnmarshalTL(r io.Reader) error { return nil } +type LiteServerGetMasterchainInfoRequest struct{} + +func (t *LiteServerGetMasterchainInfoRequest) UnmarshalTL(r io.Reader) error { + return nil +} + func (c *Client) LiteServerGetMasterchainInfo(ctx context.Context) (res LiteServerMasterchainInfoC, err error) { payload := make([]byte, 4) binary.LittleEndian.PutUint32(payload, 0x89b5e62e) @@ -2930,6 +2936,15 @@ func (t LiteServerGetMasterchainInfoExtRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetMasterchainInfoExtRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetMasterchainInfoExt(ctx context.Context, request LiteServerGetMasterchainInfoExtRequest) (res LiteServerMasterchainInfoExtC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -2961,6 +2976,12 @@ func (c *Client) LiteServerGetMasterchainInfoExt(ctx context.Context, request Li return res, fmt.Errorf("invalid tag") } +type LiteServerGetTimeRequest struct{} + +func (t *LiteServerGetTimeRequest) UnmarshalTL(r io.Reader) error { + return nil +} + func (c *Client) LiteServerGetTime(ctx context.Context) (res LiteServerCurrentTimeC, err error) { payload := make([]byte, 4) binary.LittleEndian.PutUint32(payload, 0x16ad5a34) @@ -2987,6 +3008,12 @@ func (c *Client) LiteServerGetTime(ctx context.Context) (res LiteServerCurrentTi return res, fmt.Errorf("invalid tag") } +type LiteServerGetVersionRequest struct{} + +func (t *LiteServerGetVersionRequest) UnmarshalTL(r io.Reader) error { + return nil +} + func (c *Client) LiteServerGetVersion(ctx context.Context) (res LiteServerVersionC, err error) { payload := make([]byte, 4) binary.LittleEndian.PutUint32(payload, 0x232b940b) @@ -3034,6 +3061,15 @@ func (t LiteServerGetBlockRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetBlockRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetBlock(ctx context.Context, request LiteServerGetBlockRequest) (res LiteServerBlockDataC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3086,6 +3122,15 @@ func (t LiteServerGetStateRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetStateRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetState(ctx context.Context, request LiteServerGetStateRequest) (res LiteServerBlockStateC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3147,6 +3192,19 @@ func (t LiteServerGetBlockHeaderRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetBlockHeaderRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetBlockHeader(ctx context.Context, request LiteServerGetBlockHeaderRequest) (res LiteServerBlockHeaderC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3199,6 +3257,15 @@ func (t LiteServerSendMessageRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerSendMessageRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Body) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerSendMessage(ctx context.Context, request LiteServerSendMessageRequest) (res LiteServerSendMsgStatusC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3260,6 +3327,19 @@ func (t LiteServerGetAccountStateRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetAccountStateRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Account) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetAccountState(ctx context.Context, request LiteServerGetAccountStateRequest) (res LiteServerAccountStateC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3321,6 +3401,19 @@ func (t LiteServerGetAccountStatePrunnedRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetAccountStatePrunnedRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Account) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetAccountStatePrunned(ctx context.Context, request LiteServerGetAccountStatePrunnedRequest) (res LiteServerAccountStateC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3409,6 +3502,31 @@ func (t LiteServerRunSmcMethodRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerRunSmcMethodRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Account) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.MethodId) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Params) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerRunSmcMethod(ctx context.Context, request LiteServerRunSmcMethodRequest) (res LiteServerRunMethodResultC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3488,6 +3606,27 @@ func (t LiteServerGetShardInfoRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetShardInfoRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Workchain) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Shard) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Exact) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetShardInfo(ctx context.Context, request LiteServerGetShardInfoRequest) (res LiteServerShardInfoC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3540,6 +3679,15 @@ func (t LiteServerGetAllShardsInfoRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetAllShardsInfoRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetAllShardsInfo(ctx context.Context, request LiteServerGetAllShardsInfoRequest) (res LiteServerAllShardsInfoC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3610,6 +3758,23 @@ func (t LiteServerGetOneTransactionRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetOneTransactionRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Account) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Lt) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetOneTransaction(ctx context.Context, request LiteServerGetOneTransactionRequest) (res LiteServerTransactionInfoC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3689,6 +3854,27 @@ func (t LiteServerGetTransactionsRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetTransactionsRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Count) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Account) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Lt) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Hash) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetTransactions(ctx context.Context, request LiteServerGetTransactionsRequest) (res LiteServerTransactionListC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3772,6 +3958,35 @@ func (t LiteServerLookupBlockRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerLookupBlockRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + if (t.Mode>>1)&1 == 1 { + var tempLt uint64 + err = tl.Unmarshal(r, &tempLt) + if err != nil { + return err + } + t.Lt = &tempLt + } + if (t.Mode>>2)&1 == 1 { + var tempUtime uint32 + err = tl.Unmarshal(r, &tempUtime) + if err != nil { + return err + } + t.Utime = &tempUtime + } + return nil +} + func (c *Client) LiteServerLookupBlock(ctx context.Context, request LiteServerLookupBlockRequest) (res LiteServerBlockHeaderC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3864,6 +4079,39 @@ func (t LiteServerLookupBlockWithProofRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerLookupBlockWithProofRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.McBlockId) + if err != nil { + return err + } + if (t.Mode>>1)&1 == 1 { + var tempLt uint64 + err = tl.Unmarshal(r, &tempLt) + if err != nil { + return err + } + t.Lt = &tempLt + } + if (t.Mode>>2)&1 == 1 { + var tempUtime uint32 + err = tl.Unmarshal(r, &tempUtime) + if err != nil { + return err + } + t.Utime = &tempUtime + } + return nil +} + func (c *Client) LiteServerLookupBlockWithProof(ctx context.Context, request LiteServerLookupBlockWithProofRequest) (res LiteServerLookupBlockResultC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -3945,6 +4193,51 @@ func (t LiteServerListBlockTransactionsRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerListBlockTransactionsRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Count) + if err != nil { + return err + } + if (t.Mode>>7)&1 == 1 { + var tempAfter LiteServerTransactionId3C + err = tl.Unmarshal(r, &tempAfter) + if err != nil { + return err + } + t.After = &tempAfter + } + if (t.Mode>>6)&1 == 1 { + var tTrue bool + err = tl.Unmarshal(r, &tTrue) + if err != nil { + return err + } + if tTrue != true { + return fmt.Errorf("not a True type") + } + } + if (t.Mode>>5)&1 == 1 { + var tTrue bool + err = tl.Unmarshal(r, &tTrue) + if err != nil { + return err + } + if tTrue != true { + return fmt.Errorf("not a True type") + } + } + return nil +} + func (c *Client) LiteServerListBlockTransactions(ctx context.Context, request LiteServerListBlockTransactionsRequest) (res LiteServerBlockTransactionsC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4026,6 +4319,51 @@ func (t LiteServerListBlockTransactionsExtRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerListBlockTransactionsExtRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Count) + if err != nil { + return err + } + if (t.Mode>>7)&1 == 1 { + var tempAfter LiteServerTransactionId3C + err = tl.Unmarshal(r, &tempAfter) + if err != nil { + return err + } + t.After = &tempAfter + } + if (t.Mode>>6)&1 == 1 { + var tTrue bool + err = tl.Unmarshal(r, &tTrue) + if err != nil { + return err + } + if tTrue != true { + return fmt.Errorf("not a True type") + } + } + if (t.Mode>>5)&1 == 1 { + var tTrue bool + err = tl.Unmarshal(r, &tTrue) + if err != nil { + return err + } + if tTrue != true { + return fmt.Errorf("not a True type") + } + } + return nil +} + func (c *Client) LiteServerListBlockTransactionsExt(ctx context.Context, request LiteServerListBlockTransactionsExtRequest) (res LiteServerBlockTransactionsExtC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4098,6 +4436,27 @@ func (t LiteServerGetBlockProofRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetBlockProofRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.KnownBlock) + if err != nil { + return err + } + if (t.Mode>>0)&1 == 1 { + var tempTargetBlock TonNodeBlockIdExtC + err = tl.Unmarshal(r, &tempTargetBlock) + if err != nil { + return err + } + t.TargetBlock = &tempTargetBlock + } + return nil +} + func (c *Client) LiteServerGetBlockProof(ctx context.Context, request LiteServerGetBlockProofRequest) (res LiteServerPartialBlockProofC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4159,6 +4518,19 @@ func (t LiteServerGetConfigAllRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetConfigAllRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetConfigAll(ctx context.Context, request LiteServerGetConfigAllRequest) (res LiteServerConfigInfoC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4229,6 +4601,23 @@ func (t LiteServerGetConfigParamsRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetConfigParamsRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.ParamList) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetConfigParams(ctx context.Context, request LiteServerGetConfigParamsRequest) (res LiteServerConfigInfoC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4321,6 +4710,39 @@ func (t LiteServerGetValidatorStatsRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetValidatorStatsRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Limit) + if err != nil { + return err + } + if (t.Mode>>0)&1 == 1 { + var tempStartAfter tl.Int256 + err = tl.Unmarshal(r, &tempStartAfter) + if err != nil { + return err + } + t.StartAfter = &tempStartAfter + } + if (t.Mode>>2)&1 == 1 { + var tempModifiedAfter uint32 + err = tl.Unmarshal(r, &tempModifiedAfter) + if err != nil { + return err + } + t.ModifiedAfter = &tempModifiedAfter + } + return nil +} + func (c *Client) LiteServerGetValidatorStats(ctx context.Context, request LiteServerGetValidatorStatsRequest) (res LiteServerValidatorStatsC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4373,6 +4795,15 @@ func (t LiteServerGetLibrariesRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetLibrariesRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.LibraryList) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetLibraries(ctx context.Context, request LiteServerGetLibrariesRequest) (res LiteServerLibraryResultC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4443,6 +4874,23 @@ func (t LiteServerGetLibrariesWithProofRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetLibrariesWithProofRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.LibraryList) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetLibrariesWithProof(ctx context.Context, request LiteServerGetLibrariesWithProofRequest) (res LiteServerLibraryResultWithProofC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4495,6 +4943,15 @@ func (t LiteServerGetShardBlockProofRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetShardBlockProofRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + return nil +} + func (c *Client) LiteServerGetShardBlockProof(ctx context.Context, request LiteServerGetShardBlockProofRequest) (res LiteServerShardBlockProofC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4569,6 +5026,31 @@ func (t LiteServerGetOutMsgQueueSizesRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetOutMsgQueueSizesRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + if (t.Mode>>0)&1 == 1 { + var tempWc uint32 + err = tl.Unmarshal(r, &tempWc) + if err != nil { + return err + } + t.Wc = &tempWc + } + if (t.Mode>>0)&1 == 1 { + var tempShard uint64 + err = tl.Unmarshal(r, &tempShard) + if err != nil { + return err + } + t.Shard = &tempShard + } + return nil +} + func (c *Client) LiteServerGetOutMsgQueueSizes(ctx context.Context, request LiteServerGetOutMsgQueueSizesRequest) (res LiteServerOutMsgQueueSizesC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4650,6 +5132,41 @@ func (t LiteServerGetDispatchQueueInfoRequest) MarshalTL() ([]byte, error) { return buf.Bytes(), nil } +func (t *LiteServerGetDispatchQueueInfoRequest) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Mode) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.Id) + if err != nil { + return err + } + if (t.Mode>>1)&1 == 1 { + var tempAfterAddr tl.Int256 + err = tl.Unmarshal(r, &tempAfterAddr) + if err != nil { + return err + } + t.AfterAddr = &tempAfterAddr + } + err = tl.Unmarshal(r, &t.MaxAccounts) + if err != nil { + return err + } + if (t.Mode>>0)&1 == 1 { + var tTrue bool + err = tl.Unmarshal(r, &tTrue) + if err != nil { + return err + } + if tTrue != true { + return fmt.Errorf("not a True type") + } + } + return nil +} + func (c *Client) LiteServerGetDispatchQueueInfo(ctx context.Context, request LiteServerGetDispatchQueueInfoRequest) (res LiteServerDispatchQueueInfoC, err error) { payload, err := tl.Marshal(struct { tl.SumType @@ -4680,3 +5197,124 @@ func (c *Client) LiteServerGetDispatchQueueInfo(ctx context.Context, request Lit } return res, fmt.Errorf("invalid tag") } + +var ( + // 0x5a698507 + decodeFuncLiteServerGetAccountStatePrunnedRequest = decodeRequest(0x5a698507, LiteServerGetAccountStatePrunnedRequestName, LiteServerGetAccountStatePrunnedRequest{}) + // 0x6b890e25 + decodeFuncLiteServerGetAccountStateRequest = decodeRequest(0x6b890e25, LiteServerGetAccountStateRequestName, LiteServerGetAccountStateRequest{}) + // 0x74d3fd6b + decodeFuncLiteServerGetAllShardsInfoRequest = decodeRequest(0x74d3fd6b, LiteServerGetAllShardsInfoRequestName, LiteServerGetAllShardsInfoRequest{}) + // 0x21ec069e + decodeFuncLiteServerGetBlockHeaderRequest = decodeRequest(0x21ec069e, LiteServerGetBlockHeaderRequestName, LiteServerGetBlockHeaderRequest{}) + // 0x8aea9c44 + decodeFuncLiteServerGetBlockProofRequest = decodeRequest(0x8aea9c44, LiteServerGetBlockProofRequestName, LiteServerGetBlockProofRequest{}) + // 0x6377cf0d + decodeFuncLiteServerGetBlockRequest = decodeRequest(0x6377cf0d, LiteServerGetBlockRequestName, LiteServerGetBlockRequest{}) + // 0x911b26b7 + decodeFuncLiteServerGetConfigAllRequest = decodeRequest(0x911b26b7, LiteServerGetConfigAllRequestName, LiteServerGetConfigAllRequest{}) + // 0x2a111c19 + decodeFuncLiteServerGetConfigParamsRequest = decodeRequest(0x2a111c19, LiteServerGetConfigParamsRequestName, LiteServerGetConfigParamsRequest{}) + // 0x01e66bf3 + decodeFuncLiteServerGetDispatchQueueInfoRequest = decodeRequest(0x01e66bf3, LiteServerGetDispatchQueueInfoRequestName, LiteServerGetDispatchQueueInfoRequest{}) + // 0xd122b662 + decodeFuncLiteServerGetLibrariesRequest = decodeRequest(0xd122b662, LiteServerGetLibrariesRequestName, LiteServerGetLibrariesRequest{}) + // 0x8c026c31 + decodeFuncLiteServerGetLibrariesWithProofRequest = decodeRequest(0x8c026c31, LiteServerGetLibrariesWithProofRequestName, LiteServerGetLibrariesWithProofRequest{}) + // 0x70a671df + decodeFuncLiteServerGetMasterchainInfoExtRequest = decodeRequest(0x70a671df, LiteServerGetMasterchainInfoExtRequestName, LiteServerGetMasterchainInfoExtRequest{}) + // 0x89b5e62e + decodeFuncLiteServerGetMasterchainInfoRequest = decodeRequest(0x89b5e62e, LiteServerGetMasterchainInfoRequestName, LiteServerGetMasterchainInfoRequest{}) + // 0xd40f24ea + decodeFuncLiteServerGetOneTransactionRequest = decodeRequest(0xd40f24ea, LiteServerGetOneTransactionRequestName, LiteServerGetOneTransactionRequest{}) + // 0x7bc19c36 + decodeFuncLiteServerGetOutMsgQueueSizesRequest = decodeRequest(0x7bc19c36, LiteServerGetOutMsgQueueSizesRequestName, LiteServerGetOutMsgQueueSizesRequest{}) + // 0x4ca60350 + decodeFuncLiteServerGetShardBlockProofRequest = decodeRequest(0x4ca60350, LiteServerGetShardBlockProofRequestName, LiteServerGetShardBlockProofRequest{}) + // 0x46a2f425 + decodeFuncLiteServerGetShardInfoRequest = decodeRequest(0x46a2f425, LiteServerGetShardInfoRequestName, LiteServerGetShardInfoRequest{}) + // 0xba6e2eb6 + decodeFuncLiteServerGetStateRequest = decodeRequest(0xba6e2eb6, LiteServerGetStateRequestName, LiteServerGetStateRequest{}) + // 0x16ad5a34 + decodeFuncLiteServerGetTimeRequest = decodeRequest(0x16ad5a34, LiteServerGetTimeRequestName, LiteServerGetTimeRequest{}) + // 0x1c40e7a1 + decodeFuncLiteServerGetTransactionsRequest = decodeRequest(0x1c40e7a1, LiteServerGetTransactionsRequestName, LiteServerGetTransactionsRequest{}) + // 0x091a58bc + decodeFuncLiteServerGetValidatorStatsRequest = decodeRequest(0x091a58bc, LiteServerGetValidatorStatsRequestName, LiteServerGetValidatorStatsRequest{}) + // 0x232b940b + decodeFuncLiteServerGetVersionRequest = decodeRequest(0x232b940b, LiteServerGetVersionRequestName, LiteServerGetVersionRequest{}) + // 0x0079dd5c + decodeFuncLiteServerListBlockTransactionsExtRequest = decodeRequest(0x0079dd5c, LiteServerListBlockTransactionsExtRequestName, LiteServerListBlockTransactionsExtRequest{}) + // 0xadfcc7da + decodeFuncLiteServerListBlockTransactionsRequest = decodeRequest(0xadfcc7da, LiteServerListBlockTransactionsRequestName, LiteServerListBlockTransactionsRequest{}) + // 0xfac8f71e + decodeFuncLiteServerLookupBlockRequest = decodeRequest(0xfac8f71e, LiteServerLookupBlockRequestName, LiteServerLookupBlockRequest{}) + // 0x9c045ff8 + decodeFuncLiteServerLookupBlockWithProofRequest = decodeRequest(0x9c045ff8, LiteServerLookupBlockWithProofRequestName, LiteServerLookupBlockWithProofRequest{}) + // 0x5cc65dd2 + decodeFuncLiteServerRunSmcMethodRequest = decodeRequest(0x5cc65dd2, LiteServerRunSmcMethodRequestName, LiteServerRunSmcMethodRequest{}) + // 0x690ad482 + decodeFuncLiteServerSendMessageRequest = decodeRequest(0x690ad482, LiteServerSendMessageRequestName, LiteServerSendMessageRequest{}) +) + +var taggedRequestDecodeFunctions = map[uint32]reqDecoderFunc{ + 0x5a698507: decodeFuncLiteServerGetAccountStatePrunnedRequest, + 0x6b890e25: decodeFuncLiteServerGetAccountStateRequest, + 0x74d3fd6b: decodeFuncLiteServerGetAllShardsInfoRequest, + 0x21ec069e: decodeFuncLiteServerGetBlockHeaderRequest, + 0x8aea9c44: decodeFuncLiteServerGetBlockProofRequest, + 0x6377cf0d: decodeFuncLiteServerGetBlockRequest, + 0x911b26b7: decodeFuncLiteServerGetConfigAllRequest, + 0x2a111c19: decodeFuncLiteServerGetConfigParamsRequest, + 0x01e66bf3: decodeFuncLiteServerGetDispatchQueueInfoRequest, + 0xd122b662: decodeFuncLiteServerGetLibrariesRequest, + 0x8c026c31: decodeFuncLiteServerGetLibrariesWithProofRequest, + 0x70a671df: decodeFuncLiteServerGetMasterchainInfoExtRequest, + 0x89b5e62e: decodeFuncLiteServerGetMasterchainInfoRequest, + 0xd40f24ea: decodeFuncLiteServerGetOneTransactionRequest, + 0x7bc19c36: decodeFuncLiteServerGetOutMsgQueueSizesRequest, + 0x4ca60350: decodeFuncLiteServerGetShardBlockProofRequest, + 0x46a2f425: decodeFuncLiteServerGetShardInfoRequest, + 0xba6e2eb6: decodeFuncLiteServerGetStateRequest, + 0x16ad5a34: decodeFuncLiteServerGetTimeRequest, + 0x1c40e7a1: decodeFuncLiteServerGetTransactionsRequest, + 0x091a58bc: decodeFuncLiteServerGetValidatorStatsRequest, + 0x232b940b: decodeFuncLiteServerGetVersionRequest, + 0x0079dd5c: decodeFuncLiteServerListBlockTransactionsExtRequest, + 0xadfcc7da: decodeFuncLiteServerListBlockTransactionsRequest, + 0xfac8f71e: decodeFuncLiteServerLookupBlockRequest, + 0x9c045ff8: decodeFuncLiteServerLookupBlockWithProofRequest, + 0x5cc65dd2: decodeFuncLiteServerRunSmcMethodRequest, + 0x690ad482: decodeFuncLiteServerSendMessageRequest, +} + +const ( + LiteServerGetAccountStatePrunnedRequestName RequestName = "liteServer.getAccountStatePrunned" + LiteServerGetAccountStateRequestName RequestName = "liteServer.getAccountState" + LiteServerGetAllShardsInfoRequestName RequestName = "liteServer.getAllShardsInfo" + LiteServerGetBlockHeaderRequestName RequestName = "liteServer.getBlockHeader" + LiteServerGetBlockProofRequestName RequestName = "liteServer.getBlockProof" + LiteServerGetBlockRequestName RequestName = "liteServer.getBlock" + LiteServerGetConfigAllRequestName RequestName = "liteServer.getConfigAll" + LiteServerGetConfigParamsRequestName RequestName = "liteServer.getConfigParams" + LiteServerGetDispatchQueueInfoRequestName RequestName = "liteServer.getDispatchQueueInfo" + LiteServerGetLibrariesRequestName RequestName = "liteServer.getLibraries" + LiteServerGetLibrariesWithProofRequestName RequestName = "liteServer.getLibrariesWithProof" + LiteServerGetMasterchainInfoExtRequestName RequestName = "liteServer.getMasterchainInfoExt" + LiteServerGetMasterchainInfoRequestName RequestName = "liteServer.getMasterchainInfo" + LiteServerGetOneTransactionRequestName RequestName = "liteServer.getOneTransaction" + LiteServerGetOutMsgQueueSizesRequestName RequestName = "liteServer.getOutMsgQueueSizes" + LiteServerGetShardBlockProofRequestName RequestName = "liteServer.getShardBlockProof" + LiteServerGetShardInfoRequestName RequestName = "liteServer.getShardInfo" + LiteServerGetStateRequestName RequestName = "liteServer.getState" + LiteServerGetTimeRequestName RequestName = "liteServer.getTime" + LiteServerGetTransactionsRequestName RequestName = "liteServer.getTransactions" + LiteServerGetValidatorStatsRequestName RequestName = "liteServer.getValidatorStats" + LiteServerGetVersionRequestName RequestName = "liteServer.getVersion" + LiteServerListBlockTransactionsExtRequestName RequestName = "liteServer.listBlockTransactionsExt" + LiteServerListBlockTransactionsRequestName RequestName = "liteServer.listBlockTransactions" + LiteServerLookupBlockRequestName RequestName = "liteServer.lookupBlock" + LiteServerLookupBlockWithProofRequestName RequestName = "liteServer.lookupBlockWithProof" + LiteServerRunSmcMethodRequestName RequestName = "liteServer.runSmcMethod" + LiteServerSendMessageRequestName RequestName = "liteServer.sendMessage" +) diff --git a/tl/parser/generator.go b/tl/parser/generator.go index 05987706..6dc56658 100644 --- a/tl/parser/generator.go +++ b/tl/parser/generator.go @@ -1,12 +1,15 @@ package parser import ( + "bytes" + _ "embed" "encoding/binary" "encoding/hex" "fmt" "github.com/tonkeeper/tongo/utils" "go/format" "strings" + "text/template" ) type DefaultType struct { @@ -36,21 +39,29 @@ var ( functionReturnErr = "if err != nil {return res, %s}\n" ) +var ( + //go:embed decoding.tmpl + decodingTemplate string +) + type Generator struct { - knownTypes map[string]DefaultType - newTlTypes map[string]tlType - typeName string + knownTypes map[string]DefaultType + newTlTypes map[string]tlType + typeName string + newRequestTypes map[string]tlType } func NewGenerator(knownTypes map[string]DefaultType, typeName string) *Generator { tlTypes := make(map[string]tlType) + requestTypes := make(map[string]tlType) if knownTypes == nil { knownTypes = defaultKnownTypes } return &Generator{ - knownTypes: knownTypes, - newTlTypes: tlTypes, - typeName: typeName, + knownTypes: knownTypes, + newTlTypes: tlTypes, + typeName: typeName, + newRequestTypes: requestTypes, } } @@ -105,24 +116,33 @@ func (g *Generator) LoadTypes(declarations []CombinatorDeclaration) (string, err func (g *Generator) LoadFunctions(functions []CombinatorDeclaration) (string, error) { s := "" for _, c := range functions { + requestType, err := g.generateGolangMethodRequestType(c) + if err != nil { + return "", err + } + g.newRequestTypes[c.Constructor] = requestType + s += "\n" + requestType.definition + "\n" if len(c.FieldDefinitions) > 0 { - name, requestType, err := g.generateGolangMethodRequestType(c) - if err != nil { - return "", err - } - s += "\n" + requestType + "\n" - marshaler, err := g.generateMarshalers([]CombinatorDeclaration{c}, name) + marshaler, err := g.generateMarshalers([]CombinatorDeclaration{c}, requestType.name) if err != nil { return "", err } s += "\n" + marshaler + "\n" } + unmarshler, err := g.generateUnmarshalers([]CombinatorDeclaration{c}, requestType.name) + if err != nil { + return "", err + } + s += "\n" + unmarshler + "\n" method, err := g.generateGolangMethod(g.typeName, c) if err != nil { return "", err } s += "\n" + method + "\n" } + decoder := g.generateRequestDecoder() + s += "\n" + decoder + "\n" + b, err := format.Source([]byte(s)) if err != nil { return s, err @@ -288,14 +308,15 @@ func toGolangType(t TypeExpression, optional bool, defaultTypes map[string]Defau func (g *Generator) generateUnmarshalers(declarations []CombinatorDeclaration, receiverType string) (string, error) { builder := strings.Builder{} builder.WriteString(fmt.Sprintf("func (t *%s) UnmarshalTL(r io.Reader) error {\n", receiverType)) - builder.WriteString("var err error\n") - if len(declarations) == 1 { + if len(declarations) == 1 && len(declarations[0].FieldDefinitions) > 0 { + builder.WriteString("var err error\n") s, err := g.generateSimpleTypeUnmarshaler(declarations[0]) if err != nil { return "", err } builder.WriteString(s) - } else { + } else if len(declarations) > 1 { + builder.WriteString("var err error\n") s, err := g.generateSumTypeUnmarshaler(declarations) if err != nil { return "", err @@ -306,7 +327,6 @@ func (g *Generator) generateUnmarshalers(declarations []CombinatorDeclaration, r builder.WriteString("return nil\n") builder.WriteRune('}') return builder.String(), nil - } func (g *Generator) generateSimpleTypeUnmarshaler(declaration CombinatorDeclaration) (string, error) { @@ -332,6 +352,15 @@ func (g *Generator) generateUnmarshalerCode(declaration CombinatorDeclaration, r typeString := gt.String() builder.WriteString(fmt.Sprintf("if (t.%s>>%s)&1 == 1{\n", utils.ToCamelCase(field.Modificator.Name), field.Modificator.Bit)) + if typeString == "True" { + // TODO: add field? + builder.WriteString("var tTrue bool\n") + builder.WriteString("err = tl.Unmarshal(r, &tTrue)\n") + builder.WriteString(unmarshalerReturnErr) + builder.WriteString("if tTrue != true {return fmt.Errorf(\"not a True type\")}\n") + builder.WriteString("}\n") + continue + } builder.WriteString(fmt.Sprintf("var temp%s %s\n", name, typeString)) builder.WriteString("err = tl.Unmarshal(r, &temp" + name + ")\n") builder.WriteString(unmarshalerReturnErr) @@ -562,8 +591,54 @@ func (g *Generator) generateGolangMethod(typeName string, c CombinatorDeclaratio return builder.String(), nil } -func (g *Generator) generateGolangMethodRequestType(c CombinatorDeclaration) (string, string, error) { - s, err := g.generateGolangStruct(c) +func (g *Generator) generateGolangMethodRequestType(c CombinatorDeclaration) (tlType, error) { name := utils.ToCamelCase(c.Constructor) + "Request" - return name, fmt.Sprintf("type %s %s", name, s), err + s, err := g.generateGolangStruct(c) + if err != nil { + return tlType{}, err + } + tag, err := tagToUint32(c.Tag) + if err != nil { + return tlType{}, err + } + return tlType{ + name: name, + tags: []uint32{tag}, + definition: fmt.Sprintf("type %s %s", name, s), + }, nil +} + +func (g *Generator) generateRequestDecoder() string { + type msg struct { + TlName string + Name string + Tag uint32 + } + type messagesContext struct { + Types map[string]msg + WhatRender string + } + reqContext := messagesContext{Types: map[string]msg{}, WhatRender: "Request"} + for tlName, val := range g.newRequestTypes { + if len(val.tags) != 1 { + panic("sum type is not supported in the request") + } + reqContext.Types[val.name] = msg{ + Name: val.name, + Tag: val.tags[0], + TlName: tlName, + } + } + tmpl, err := template.New("decoding").Parse(decodingTemplate) + if err != nil { + panic(err) + return "" + } + var buf bytes.Buffer + if err := tmpl.Execute(&buf, reqContext); err != nil { + panic(err) + return "" + } + fmt.Printf("%s", buf.String()) + return buf.String() } From 9bf0acc76ea40ff4849114efca3d6ced13d76817 Mon Sep 17 00:00:00 2001 From: Alexey Kostenko Date: Fri, 20 Sep 2024 16:08:37 +0300 Subject: [PATCH 2/5] template --- tl/parser/decoding.tmpl | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 tl/parser/decoding.tmpl diff --git a/tl/parser/decoding.tmpl b/tl/parser/decoding.tmpl new file mode 100644 index 00000000..d97e5f5b --- /dev/null +++ b/tl/parser/decoding.tmpl @@ -0,0 +1,20 @@ + + +var ( +{{- range $name, $type := .Types }} + // 0x{{ printf "%08x" $type.Tag }} + decodeFunc{{ $type.Name }} = decodeRequest(0x{{ printf "%08x" $type.Tag }}, {{ $name }}Name, {{ $name }}{}) +{{- end }} +) + +var tagged{{ $.WhatRender }}DecodeFunctions = map[uint32]reqDecoderFunc { +{{- range $name, $type := .Types }} + 0x{{ printf "%08x" $type.Tag }}: decodeFunc{{ $type.Name }}, +{{- end }} +} + +const ( +{{- range $name, $type := .Types }} + {{ $name }}Name RequestName = "{{ $type.TlName }}" +{{- end }} +) From e0f0258733388707ec57b88e9f503464f460f98d Mon Sep 17 00:00:00 2001 From: Alexey Kostenko Date: Fri, 20 Sep 2024 16:20:01 +0300 Subject: [PATCH 3/5] get limit method --- liteclient/generated.go | 79 +++++++++++++++++++++++++++++++++++++++++ liteclient/lite_api.tl | 2 ++ 2 files changed, 81 insertions(+) diff --git a/liteclient/generated.go b/liteclient/generated.go index 54a1209a..0120c4bd 100644 --- a/liteclient/generated.go +++ b/liteclient/generated.go @@ -2853,6 +2853,49 @@ func (t *LiteServerDispatchQueueInfoC) UnmarshalTL(r io.Reader) error { return nil } +type LiteProxyRequestRateLimitC struct { + Limit uint32 + PerTime uint32 +} + +func (t LiteProxyRequestRateLimitC) MarshalTL() ([]byte, error) { + var ( + err error + b []byte + ) + buf := new(bytes.Buffer) + b, err = tl.Marshal(t.Limit) + if err != nil { + return nil, err + } + _, err = buf.Write(b) + if err != nil { + return nil, err + } + b, err = tl.Marshal(t.PerTime) + if err != nil { + return nil, err + } + _, err = buf.Write(b) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +func (t *LiteProxyRequestRateLimitC) UnmarshalTL(r io.Reader) error { + var err error + err = tl.Unmarshal(r, &t.Limit) + if err != nil { + return err + } + err = tl.Unmarshal(r, &t.PerTime) + if err != nil { + return err + } + return nil +} + type LiteServerDebugVerbosityC struct { Value uint32 } @@ -5198,7 +5241,41 @@ func (c *Client) LiteServerGetDispatchQueueInfo(ctx context.Context, request Lit return res, fmt.Errorf("invalid tag") } +type LiteProxyGetRequestRateLimitRequest struct{} + +func (t *LiteProxyGetRequestRateLimitRequest) UnmarshalTL(r io.Reader) error { + return nil +} + +func (c *Client) LiteProxyGetRequestRateLimit(ctx context.Context) (res LiteProxyRequestRateLimitC, err error) { + payload := make([]byte, 4) + binary.LittleEndian.PutUint32(payload, 0xf0f83e86) + resp, err := c.liteServerRequest(ctx, payload) + if err != nil { + return res, err + } + if len(resp) < 4 { + return res, fmt.Errorf("not enough bytes for tag") + } + tag := binary.LittleEndian.Uint32(resp[:4]) + if tag == 0xbba9e148 { + var errRes LiteServerErrorC + err = tl.Unmarshal(bytes.NewReader(resp[4:]), &errRes) + if err != nil { + return res, err + } + return res, errRes + } + if tag == 0x14cb3f0c { + err = tl.Unmarshal(bytes.NewReader(resp[4:]), &res) + return res, err + } + return res, fmt.Errorf("invalid tag") +} + var ( + // 0xf0f83e86 + decodeFuncLiteProxyGetRequestRateLimitRequest = decodeRequest(0xf0f83e86, LiteProxyGetRequestRateLimitRequestName, LiteProxyGetRequestRateLimitRequest{}) // 0x5a698507 decodeFuncLiteServerGetAccountStatePrunnedRequest = decodeRequest(0x5a698507, LiteServerGetAccountStatePrunnedRequestName, LiteServerGetAccountStatePrunnedRequest{}) // 0x6b890e25 @@ -5258,6 +5335,7 @@ var ( ) var taggedRequestDecodeFunctions = map[uint32]reqDecoderFunc{ + 0xf0f83e86: decodeFuncLiteProxyGetRequestRateLimitRequest, 0x5a698507: decodeFuncLiteServerGetAccountStatePrunnedRequest, 0x6b890e25: decodeFuncLiteServerGetAccountStateRequest, 0x74d3fd6b: decodeFuncLiteServerGetAllShardsInfoRequest, @@ -5289,6 +5367,7 @@ var taggedRequestDecodeFunctions = map[uint32]reqDecoderFunc{ } const ( + LiteProxyGetRequestRateLimitRequestName RequestName = "liteProxy.getRequestRateLimit" LiteServerGetAccountStatePrunnedRequestName RequestName = "liteServer.getAccountStatePrunned" LiteServerGetAccountStateRequestName RequestName = "liteServer.getAccountState" LiteServerGetAllShardsInfoRequestName RequestName = "liteServer.getAllShardsInfo" diff --git a/liteclient/lite_api.tl b/liteclient/lite_api.tl index 697087c8..a76535fc 100644 --- a/liteclient/lite_api.tl +++ b/liteclient/lite_api.tl @@ -62,6 +62,7 @@ liteServer.outMsgQueueSize#a7c64c85 id:tonNode.blockIdExt size:int = liteServer. liteServer.outMsgQueueSizes#f8504a03 shards:(vector liteServer.outMsgQueueSize) ext_msg_queue_size_limit:int = liteServer.OutMsgQueueSizes; liteServer.accountDispatchQueueInfo#9b52aabb addr:int256 size:long min_lt:long max_lt:long = liteServer.AccountDispatchQueueInfo; liteServer.dispatchQueueInfo#5d1132d0 mode:# id:tonNode.blockIdExt account_dispatch_queues:(vector liteServer.accountDispatchQueueInfo) complete:Bool proof:mode.0?bytes = liteServer.DispatchQueueInfo; +liteProxy.requestRateLimit#14cb3f0c limit:int per_time:int = liteProxy.RequestRateLimit; liteServer.debug.verbosity#5d404733 value:int = liteServer.debug.Verbosity; @@ -102,6 +103,7 @@ liteServer.getLibrariesWithProof#8c026c31 id:tonNode.blockIdExt mode:# library_l liteServer.getShardBlockProof#4ca60350 id:tonNode.blockIdExt = liteServer.ShardBlockProof; liteServer.getOutMsgQueueSizes#7bc19c36 mode:# wc:mode.0?int shard:mode.0?long = liteServer.OutMsgQueueSizes; liteServer.getDispatchQueueInfo#01e66bf3 mode:# id:tonNode.blockIdExt after_addr:mode.1?int256 max_accounts:int want_proof:mode.0?true = liteServer.DispatchQueueInfo; +liteProxy.getRequestRateLimit#f0f83e86 = liteProxy.RequestRateLimit; // liteServer.nonfinal.getValidatorGroups mode:# wc:mode.0?int shard:mode.1?long = liteServer.nonfinal.ValidatorGroups; // liteServer.nonfinal.getCandidate id:liteServer.nonfinal.candidateId = liteServer.nonfinal.Candidate; From 8f0f12a6cc56faf0e54b8967d705414080ed8121 Mon Sep 17 00:00:00 2001 From: Alexey Kostenko Date: Fri, 20 Sep 2024 16:37:52 +0300 Subject: [PATCH 4/5] remove pointer --- liteclient/decoder.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/liteclient/decoder.go b/liteclient/decoder.go index 2ebe1818..96dbbf92 100644 --- a/liteclient/decoder.go +++ b/liteclient/decoder.go @@ -40,17 +40,17 @@ func decodeRequest(tag uint32, name RequestName, msgType any) reqDecoderFunc { type reqDecoderFunc func(b []byte) (*RequestName, any, error) -func LiteapiRequestDecoder(b []byte) (*uint32, *RequestName, any, error) { +func LiteapiRequestDecoder(b []byte) (uint32, *RequestName, any, error) { if len(b) < 4 { - return nil, nil, nil, errors.New("message too short") + return 0, nil, nil, errors.New("message too short") } tag := binary.LittleEndian.Uint32(b[:4]) f := taggedRequestDecodeFunctions[tag] if f != nil { o, d, err := f(b) if err == nil { - return &tag, o, d, nil + return tag, o, d, nil } } - return &tag, pointer(UnknownRequest), nil, nil + return tag, pointer(UnknownRequest), nil, nil } From d31567a9c81af80a9562d45a25e241b52d790f2a Mon Sep 17 00:00:00 2001 From: Alexey Kostenko Date: Fri, 20 Sep 2024 21:09:56 +0300 Subject: [PATCH 5/5] TL string encoder --- tl/encoder.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tl/encoder.go b/tl/encoder.go index a065ae92..8f9533e7 100644 --- a/tl/encoder.go +++ b/tl/encoder.go @@ -45,6 +45,10 @@ func Marshal(o any) ([]byte, error) { binary.BigEndian.PutUint32(b, 0x379779bc) // false } return b, nil + case reflect.String: + data := []byte(val.String()) + b := append(EncodeLength(len(data)), data...) + return zeroPadding(b), nil case reflect.Slice: if val.Type().Elem().Kind() != reflect.Uint8 { return encodeVector(val)