diff --git a/api/openapi.yml b/api/openapi.yml index 5b8f596..dd876b2 100644 --- a/api/openapi.yml +++ b/api/openapi.yml @@ -45,6 +45,40 @@ paths: $ref: '#/components/schemas/BlockchainBlockShards' 'default': $ref: '#/components/responses/Error' + /v2/blockchain/masterchain/{masterchain_seqno}/blocks: + get: + description: Get all blocks in all shards and workchains between target and previous masterchain block according to shards last blocks snapshot in masterchain. We don't recommend to build your app around this method because it has problem with scalability and will work very slow in the future. + operationId: getBlockchainMasterchainBlocks + tags: + - Blockchain + parameters: + - $ref: '#/components/parameters/masterchainSeqno' + responses: + '200': + description: blockchain blocks + content: + application/json: + schema: + $ref: '#/components/schemas/BlockchainBlocks' + 'default': + $ref: '#/components/responses/Error' + /v2/blockchain/masterchain/{masterchain_seqno}/transactions: + get: + description: Get all transactions in all shards and workchains between target and previous masterchain block according to shards last blocks snapshot in masterchain. We don't recommend to build your app around this method because it has problem with scalability and will work very slow in the future. + operationId: getBlockchainMasterchainTransactions + tags: + - Blockchain + parameters: + - $ref: '#/components/parameters/masterchainSeqno' + responses: + '200': + description: blockchain transactions + content: + application/json: + schema: + $ref: '#/components/schemas/Transactions' + 'default': + $ref: '#/components/responses/Error' /v2/blockchain/masterchain/{masterchain_seqno}/config: get: description: Get blockchain config from a specific block, if present. @@ -303,6 +337,23 @@ paths: $ref: '#/components/schemas/BlockchainAccountInspect' 'default': $ref: '#/components/responses/Error' + /v2/message/decode: + post: + description: Decode a given message. Only external incoming messages can be decoded currently. + operationId: decodeMessage + tags: + - Emulation + requestBody: + $ref: "#/components/requestBodies/Boc" + responses: + '200': + description: decoded message + content: + application/json: + schema: + $ref: '#/components/schemas/DecodedMessage' + 'default': + $ref: '#/components/responses/Error' /v2/address/{account_id}/parse: get: description: parse address and display in all formats @@ -2680,6 +2731,65 @@ components: is_wallet: type: boolean example: true + BlockCurrencyCollection: + type: object + required: + - grams + - other + properties: + grams: + type: integer + format: int64 + example: 10000000000 + other: + type: array + items: + type: object + required: + - id + - value + properties: + id: + type: integer + format: int64 + example: 13 + value: + type: string + example: "10000000000" + BlockValueFlow: + type: object + required: + - from_prev_blk + - to_next_blk + - imported + - exported + - fees_collected + - fees_imported + - recovered + - created + - minted + properties: + from_prev_blk: + $ref: '#/components/schemas/BlockCurrencyCollection' + to_next_blk: + $ref: '#/components/schemas/BlockCurrencyCollection' + imported: + $ref: '#/components/schemas/BlockCurrencyCollection' + exported: + $ref: '#/components/schemas/BlockCurrencyCollection' + fees_collected: + $ref: '#/components/schemas/BlockCurrencyCollection' + burned: + $ref: '#/components/schemas/BlockCurrencyCollection' + fees_imported: + $ref: '#/components/schemas/BlockCurrencyCollection' + recovered: + $ref: '#/components/schemas/BlockCurrencyCollection' + created: + $ref: '#/components/schemas/BlockCurrencyCollection' + minted: + $ref: '#/components/schemas/BlockCurrencyCollection' + BlockchainBlock: type: object required: @@ -2689,7 +2799,7 @@ components: - root_hash - file_hash - global_id - # ValueFlow pgtype.JSONB + - value_flow - version - after_merge - before_split @@ -2710,6 +2820,8 @@ components: - rand_seed - created_by properties: + value_flow: + $ref: '#/components/schemas/BlockValueFlow' workchain_id: type: integer example: 0 @@ -2811,6 +2923,15 @@ components: created_by: type: string example: A6A0BD6608672B11B79538A50B2204E748305C12AA0DED9C16CF0006CE3AF8DB + BlockchainBlocks: + type: object + required: + - blocks + properties: + blocks: + type: array + items: + $ref: '#/components/schemas/BlockchainBlock' BlockchainBlockShards: type: object required: @@ -2845,6 +2966,7 @@ components: Message: type: object required: + - msg_type - created_lt - ihr_disabled - bounce @@ -2855,6 +2977,13 @@ components: - import_fee - created_at properties: + msg_type: + type: string + example: int_msg + enum: + - int_msg + - ext_in_msg + - ext_out_msg created_lt: type: integer format: int64 @@ -5360,6 +5489,116 @@ components: $ref: '#/components/schemas/AccountAddress' jetton: $ref: '#/components/schemas/JettonPreview' + DecodedMessage: + type: object + required: + - destination + - destination_wallet_version + properties: + destination: + $ref: '#/components/schemas/AccountAddress' + destination_wallet_version: + type: string + example: "v3R2" + ext_in_msg_decoded: + type: object + properties: + wallet_v3: + type: object + required: + - subwallet_id + - valid_until + - seqno + - op + - raw_messages + properties: + subwallet_id: + type: integer + format: uint32 + example: 1 + valid_until: + type: integer + format: uint32 + example: 1 + seqno: + type: integer + format: uint32 + example: 1 + raw_messages: + type: array + items: + $ref: '#/components/schemas/DecodedRawMessage' + wallet_v4: + type: object + required: + - subwallet_id + - valid_until + - seqno + - op + - raw_messages + properties: + subwallet_id: + type: integer + format: uint32 + example: 1 + valid_until: + type: integer + format: uint32 + example: 1 + seqno: + type: integer + format: uint32 + example: 1 + op: + type: integer + format: int8 + example: 1 + raw_messages: + type: array + items: + $ref: '#/components/schemas/DecodedRawMessage' + wallet_highload_v2: + type: object + required: + - subwallet_id + - bounded_query_id + - raw_messages + properties: + subwallet_id: + type: integer + format: uint32 + example: 1 + bounded_query_id: + type: string + example: "34254528475294857" + raw_messages: + type: array + items: + $ref: '#/components/schemas/DecodedRawMessage' + DecodedRawMessage: + type: object + required: + - message + - mode + properties: + message: + type: object + required: + - boc + properties: + boc: + type: string + example: "te6ccgEBAQEABgAACCiAmCMBAgEABwA=" + decoded_op_name: + type: string + example: "nft_transfer" + op_code: + type: string + example: "0xdeadbeaf" + decoded_body: { } # Free-form JSON value + mode: + type: integer + example: 2 Event: type: object required: diff --git a/oas_client_gen.go b/oas_client_gen.go index 8f88eff..3d2fdaf 100644 --- a/oas_client_gen.go +++ b/oas_client_gen.go @@ -41,6 +41,12 @@ type Invoker interface { // // GET /v2/blockchain/accounts/{account_id}/inspect BlockchainAccountInspect(ctx context.Context, params BlockchainAccountInspectParams) (*BlockchainAccountInspect, error) + // DecodeMessage invokes decodeMessage operation. + // + // Decode a given message. Only external incoming messages can be decoded currently. + // + // POST /v2/message/decode + DecodeMessage(ctx context.Context, request *DecodeMessageReq) (*DecodedMessage, error) // DnsResolve invokes dnsResolve operation. // // DNS resolve for domain name. @@ -225,6 +231,14 @@ type Invoker interface { // // GET /v2/blockchain/masterchain/{masterchain_seqno}/config GetBlockchainConfigFromBlock(ctx context.Context, params GetBlockchainConfigFromBlockParams) (*BlockchainConfig, error) + // GetBlockchainMasterchainBlocks invokes getBlockchainMasterchainBlocks operation. + // + // Get all blocks in all shards and workchains between target and previous masterchain block + // according to shards last blocks snapshot in masterchain. We don't recommend to build your app + // around this method because it has problem with scalability and will work very slow in the future. + // + // GET /v2/blockchain/masterchain/{masterchain_seqno}/blocks + GetBlockchainMasterchainBlocks(ctx context.Context, params GetBlockchainMasterchainBlocksParams) (*BlockchainBlocks, error) // GetBlockchainMasterchainHead invokes getBlockchainMasterchainHead operation. // // Get last known masterchain block. @@ -237,6 +251,14 @@ type Invoker interface { // // GET /v2/blockchain/masterchain/{masterchain_seqno}/shards GetBlockchainMasterchainShards(ctx context.Context, params GetBlockchainMasterchainShardsParams) (*BlockchainBlockShards, error) + // GetBlockchainMasterchainTransactions invokes getBlockchainMasterchainTransactions operation. + // + // Get all transactions in all shards and workchains between target and previous masterchain block + // according to shards last blocks snapshot in masterchain. We don't recommend to build your app + // around this method because it has problem with scalability and will work very slow in the future. + // + // GET /v2/blockchain/masterchain/{masterchain_seqno}/transactions + GetBlockchainMasterchainTransactions(ctx context.Context, params GetBlockchainMasterchainTransactionsParams) (*Transactions, error) // GetBlockchainRawAccount invokes getBlockchainRawAccount operation. // // Get low-level information about an account taken directly from the blockchain. @@ -849,6 +871,81 @@ func (c *Client) sendBlockchainAccountInspect(ctx context.Context, params Blockc return result, nil } +// DecodeMessage invokes decodeMessage operation. +// +// Decode a given message. Only external incoming messages can be decoded currently. +// +// POST /v2/message/decode +func (c *Client) DecodeMessage(ctx context.Context, request *DecodeMessageReq) (*DecodedMessage, error) { + res, err := c.sendDecodeMessage(ctx, request) + return res, err +} + +func (c *Client) sendDecodeMessage(ctx context.Context, request *DecodeMessageReq) (res *DecodedMessage, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("decodeMessage"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/message/decode"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "DecodeMessage", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/v2/message/decode" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeDecodeMessageRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeDecodeMessageResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // DnsResolve invokes dnsResolve operation. // // DNS resolve for domain name. @@ -4315,6 +4412,99 @@ func (c *Client) sendGetBlockchainConfigFromBlock(ctx context.Context, params Ge return result, nil } +// GetBlockchainMasterchainBlocks invokes getBlockchainMasterchainBlocks operation. +// +// Get all blocks in all shards and workchains between target and previous masterchain block +// according to shards last blocks snapshot in masterchain. We don't recommend to build your app +// around this method because it has problem with scalability and will work very slow in the future. +// +// GET /v2/blockchain/masterchain/{masterchain_seqno}/blocks +func (c *Client) GetBlockchainMasterchainBlocks(ctx context.Context, params GetBlockchainMasterchainBlocksParams) (*BlockchainBlocks, error) { + res, err := c.sendGetBlockchainMasterchainBlocks(ctx, params) + return res, err +} + +func (c *Client) sendGetBlockchainMasterchainBlocks(ctx context.Context, params GetBlockchainMasterchainBlocksParams) (res *BlockchainBlocks, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getBlockchainMasterchainBlocks"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/blockchain/masterchain/{masterchain_seqno}/blocks"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "GetBlockchainMasterchainBlocks", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v2/blockchain/masterchain/" + { + // Encode "masterchain_seqno" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "masterchain_seqno", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.Int32ToString(params.MasterchainSeqno)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/blocks" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeGetBlockchainMasterchainBlocksResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // GetBlockchainMasterchainHead invokes getBlockchainMasterchainHead operation. // // Get last known masterchain block. @@ -4478,6 +4668,99 @@ func (c *Client) sendGetBlockchainMasterchainShards(ctx context.Context, params return result, nil } +// GetBlockchainMasterchainTransactions invokes getBlockchainMasterchainTransactions operation. +// +// Get all transactions in all shards and workchains between target and previous masterchain block +// according to shards last blocks snapshot in masterchain. We don't recommend to build your app +// around this method because it has problem with scalability and will work very slow in the future. +// +// GET /v2/blockchain/masterchain/{masterchain_seqno}/transactions +func (c *Client) GetBlockchainMasterchainTransactions(ctx context.Context, params GetBlockchainMasterchainTransactionsParams) (*Transactions, error) { + res, err := c.sendGetBlockchainMasterchainTransactions(ctx, params) + return res, err +} + +func (c *Client) sendGetBlockchainMasterchainTransactions(ctx context.Context, params GetBlockchainMasterchainTransactionsParams) (res *Transactions, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getBlockchainMasterchainTransactions"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/blockchain/masterchain/{masterchain_seqno}/transactions"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "GetBlockchainMasterchainTransactions", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v2/blockchain/masterchain/" + { + // Encode "masterchain_seqno" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "masterchain_seqno", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.Int32ToString(params.MasterchainSeqno)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/transactions" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeGetBlockchainMasterchainTransactionsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // GetBlockchainRawAccount invokes getBlockchainRawAccount operation. // // Get low-level information about an account taken directly from the blockchain. diff --git a/oas_json_gen.go b/oas_json_gen.go index 7030a87..a819882 100644 --- a/oas_json_gen.go +++ b/oas_json_gen.go @@ -3457,6 +3457,242 @@ func (s *Auctions) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *BlockCurrencyCollection) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BlockCurrencyCollection) encodeFields(e *jx.Encoder) { + { + e.FieldStart("grams") + e.Int64(s.Grams) + } + { + e.FieldStart("other") + e.ArrStart() + for _, elem := range s.Other { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfBlockCurrencyCollection = [2]string{ + 0: "grams", + 1: "other", +} + +// Decode decodes BlockCurrencyCollection from json. +func (s *BlockCurrencyCollection) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BlockCurrencyCollection to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "grams": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.Grams = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"grams\"") + } + case "other": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + s.Other = make([]BlockCurrencyCollectionOtherItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem BlockCurrencyCollectionOtherItem + if err := elem.Decode(d); err != nil { + return err + } + s.Other = append(s.Other, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"other\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BlockCurrencyCollection") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBlockCurrencyCollection) { + name = jsonFieldsNameOfBlockCurrencyCollection[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BlockCurrencyCollection) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BlockCurrencyCollection) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BlockCurrencyCollectionOtherItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BlockCurrencyCollectionOtherItem) encodeFields(e *jx.Encoder) { + { + e.FieldStart("id") + e.Int64(s.ID) + } + { + e.FieldStart("value") + e.Str(s.Value) + } +} + +var jsonFieldsNameOfBlockCurrencyCollectionOtherItem = [2]string{ + 0: "id", + 1: "value", +} + +// Decode decodes BlockCurrencyCollectionOtherItem from json. +func (s *BlockCurrencyCollectionOtherItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BlockCurrencyCollectionOtherItem to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.ID = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "value": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Value = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"value\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BlockCurrencyCollectionOtherItem") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBlockCurrencyCollectionOtherItem) { + name = jsonFieldsNameOfBlockCurrencyCollectionOtherItem[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BlockCurrencyCollectionOtherItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BlockCurrencyCollectionOtherItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *BlockLimits) Encode(e *jx.Encoder) { e.ObjStart() @@ -3876,88 +4112,320 @@ func (s *BlockRaw) UnmarshalJSON(data []byte) error { } // Encode implements json.Marshaler. -func (s *BlockchainAccountInspect) Encode(e *jx.Encoder) { +func (s *BlockValueFlow) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *BlockchainAccountInspect) encodeFields(e *jx.Encoder) { +func (s *BlockValueFlow) encodeFields(e *jx.Encoder) { { - e.FieldStart("code") - e.Str(s.Code) + e.FieldStart("from_prev_blk") + s.FromPrevBlk.Encode(e) } { - e.FieldStart("code_hash") - e.Str(s.CodeHash) + e.FieldStart("to_next_blk") + s.ToNextBlk.Encode(e) } { - e.FieldStart("methods") - e.ArrStart() - for _, elem := range s.Methods { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("imported") + s.Imported.Encode(e) } { - if s.Compiler.Set { - e.FieldStart("compiler") - s.Compiler.Encode(e) + e.FieldStart("exported") + s.Exported.Encode(e) + } + { + e.FieldStart("fees_collected") + s.FeesCollected.Encode(e) + } + { + if s.Burned.Set { + e.FieldStart("burned") + s.Burned.Encode(e) } } + { + e.FieldStart("fees_imported") + s.FeesImported.Encode(e) + } + { + e.FieldStart("recovered") + s.Recovered.Encode(e) + } + { + e.FieldStart("created") + s.Created.Encode(e) + } + { + e.FieldStart("minted") + s.Minted.Encode(e) + } } -var jsonFieldsNameOfBlockchainAccountInspect = [4]string{ - 0: "code", - 1: "code_hash", - 2: "methods", - 3: "compiler", +var jsonFieldsNameOfBlockValueFlow = [10]string{ + 0: "from_prev_blk", + 1: "to_next_blk", + 2: "imported", + 3: "exported", + 4: "fees_collected", + 5: "burned", + 6: "fees_imported", + 7: "recovered", + 8: "created", + 9: "minted", } -// Decode decodes BlockchainAccountInspect from json. -func (s *BlockchainAccountInspect) Decode(d *jx.Decoder) error { +// Decode decodes BlockValueFlow from json. +func (s *BlockValueFlow) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode BlockchainAccountInspect to nil") + return errors.New("invalid: unable to decode BlockValueFlow to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [2]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "code": + case "from_prev_blk": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Code = string(v) - if err != nil { + if err := s.FromPrevBlk.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"code\"") + return errors.Wrap(err, "decode field \"from_prev_blk\"") } - case "code_hash": + case "to_next_blk": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.CodeHash = string(v) - if err != nil { + if err := s.ToNextBlk.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"code_hash\"") + return errors.Wrap(err, "decode field \"to_next_blk\"") } - case "methods": + case "imported": requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Methods = make([]BlockchainAccountInspectMethodsItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem BlockchainAccountInspectMethodsItem - if err := elem.Decode(d); err != nil { - return err - } - s.Methods = append(s.Methods, elem) + if err := s.Imported.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"imported\"") + } + case "exported": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.Exported.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"exported\"") + } + case "fees_collected": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + if err := s.FeesCollected.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"fees_collected\"") + } + case "burned": + if err := func() error { + s.Burned.Reset() + if err := s.Burned.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"burned\"") + } + case "fees_imported": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + if err := s.FeesImported.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"fees_imported\"") + } + case "recovered": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + if err := s.Recovered.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"recovered\"") + } + case "created": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + if err := s.Created.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created\"") + } + case "minted": + requiredBitSet[1] |= 1 << 1 + if err := func() error { + if err := s.Minted.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"minted\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BlockValueFlow") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b11011111, + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBlockValueFlow) { + name = jsonFieldsNameOfBlockValueFlow[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BlockValueFlow) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BlockValueFlow) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BlockchainAccountInspect) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BlockchainAccountInspect) encodeFields(e *jx.Encoder) { + { + e.FieldStart("code") + e.Str(s.Code) + } + { + e.FieldStart("code_hash") + e.Str(s.CodeHash) + } + { + e.FieldStart("methods") + e.ArrStart() + for _, elem := range s.Methods { + elem.Encode(e) + } + e.ArrEnd() + } + { + if s.Compiler.Set { + e.FieldStart("compiler") + s.Compiler.Encode(e) + } + } +} + +var jsonFieldsNameOfBlockchainAccountInspect = [4]string{ + 0: "code", + 1: "code_hash", + 2: "methods", + 3: "compiler", +} + +// Decode decodes BlockchainAccountInspect from json. +func (s *BlockchainAccountInspect) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BlockchainAccountInspect to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "code": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Code = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"code\"") + } + case "code_hash": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.CodeHash = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"code_hash\"") + } + case "methods": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Methods = make([]BlockchainAccountInspectMethodsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem BlockchainAccountInspectMethodsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Methods = append(s.Methods, elem) return nil }); err != nil { return err @@ -4192,6 +4660,10 @@ func (s *BlockchainBlock) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *BlockchainBlock) encodeFields(e *jx.Encoder) { + { + e.FieldStart("value_flow") + s.ValueFlow.Encode(e) + } { e.FieldStart("workchain_id") e.Int32(s.WorkchainID) @@ -4316,35 +4788,36 @@ func (s *BlockchainBlock) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfBlockchainBlock = [28]string{ - 0: "workchain_id", - 1: "shard", - 2: "seqno", - 3: "root_hash", - 4: "file_hash", - 5: "global_id", - 6: "version", - 7: "after_merge", - 8: "before_split", - 9: "after_split", - 10: "want_split", - 11: "want_merge", - 12: "key_block", - 13: "gen_utime", - 14: "start_lt", - 15: "end_lt", - 16: "vert_seqno", - 17: "gen_catchain_seqno", - 18: "min_ref_mc_seqno", - 19: "prev_key_block_seqno", - 20: "gen_software_version", - 21: "gen_software_capabilities", - 22: "master_ref", - 23: "prev_refs", - 24: "in_msg_descr_length", - 25: "out_msg_descr_length", - 26: "rand_seed", - 27: "created_by", +var jsonFieldsNameOfBlockchainBlock = [29]string{ + 0: "value_flow", + 1: "workchain_id", + 2: "shard", + 3: "seqno", + 4: "root_hash", + 5: "file_hash", + 6: "global_id", + 7: "version", + 8: "after_merge", + 9: "before_split", + 10: "after_split", + 11: "want_split", + 12: "want_merge", + 13: "key_block", + 14: "gen_utime", + 15: "start_lt", + 16: "end_lt", + 17: "vert_seqno", + 18: "gen_catchain_seqno", + 19: "min_ref_mc_seqno", + 20: "prev_key_block_seqno", + 21: "gen_software_version", + 22: "gen_software_capabilities", + 23: "master_ref", + 24: "prev_refs", + 25: "in_msg_descr_length", + 26: "out_msg_descr_length", + 27: "rand_seed", + 28: "created_by", } // Decode decodes BlockchainBlock from json. @@ -4356,8 +4829,18 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "workchain_id": + case "value_flow": requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.ValueFlow.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"value_flow\"") + } + case "workchain_id": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Int32() s.WorkchainID = int32(v) @@ -4369,7 +4852,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"workchain_id\"") } case "shard": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() s.Shard = string(v) @@ -4381,7 +4864,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"shard\"") } case "seqno": - requiredBitSet[0] |= 1 << 2 + requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Int32() s.Seqno = int32(v) @@ -4393,7 +4876,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"seqno\"") } case "root_hash": - requiredBitSet[0] |= 1 << 3 + requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Str() s.RootHash = string(v) @@ -4405,7 +4888,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"root_hash\"") } case "file_hash": - requiredBitSet[0] |= 1 << 4 + requiredBitSet[0] |= 1 << 5 if err := func() error { v, err := d.Str() s.FileHash = string(v) @@ -4417,7 +4900,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"file_hash\"") } case "global_id": - requiredBitSet[0] |= 1 << 5 + requiredBitSet[0] |= 1 << 6 if err := func() error { v, err := d.Int32() s.GlobalID = int32(v) @@ -4429,7 +4912,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"global_id\"") } case "version": - requiredBitSet[0] |= 1 << 6 + requiredBitSet[0] |= 1 << 7 if err := func() error { v, err := d.Int32() s.Version = int32(v) @@ -4441,7 +4924,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"version\"") } case "after_merge": - requiredBitSet[0] |= 1 << 7 + requiredBitSet[1] |= 1 << 0 if err := func() error { v, err := d.Bool() s.AfterMerge = bool(v) @@ -4453,7 +4936,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"after_merge\"") } case "before_split": - requiredBitSet[1] |= 1 << 0 + requiredBitSet[1] |= 1 << 1 if err := func() error { v, err := d.Bool() s.BeforeSplit = bool(v) @@ -4465,7 +4948,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"before_split\"") } case "after_split": - requiredBitSet[1] |= 1 << 1 + requiredBitSet[1] |= 1 << 2 if err := func() error { v, err := d.Bool() s.AfterSplit = bool(v) @@ -4477,7 +4960,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"after_split\"") } case "want_split": - requiredBitSet[1] |= 1 << 2 + requiredBitSet[1] |= 1 << 3 if err := func() error { v, err := d.Bool() s.WantSplit = bool(v) @@ -4489,7 +4972,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"want_split\"") } case "want_merge": - requiredBitSet[1] |= 1 << 3 + requiredBitSet[1] |= 1 << 4 if err := func() error { v, err := d.Bool() s.WantMerge = bool(v) @@ -4501,7 +4984,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"want_merge\"") } case "key_block": - requiredBitSet[1] |= 1 << 4 + requiredBitSet[1] |= 1 << 5 if err := func() error { v, err := d.Bool() s.KeyBlock = bool(v) @@ -4513,7 +4996,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"key_block\"") } case "gen_utime": - requiredBitSet[1] |= 1 << 5 + requiredBitSet[1] |= 1 << 6 if err := func() error { v, err := d.Int64() s.GenUtime = int64(v) @@ -4525,7 +5008,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"gen_utime\"") } case "start_lt": - requiredBitSet[1] |= 1 << 6 + requiredBitSet[1] |= 1 << 7 if err := func() error { v, err := d.Int64() s.StartLt = int64(v) @@ -4537,7 +5020,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"start_lt\"") } case "end_lt": - requiredBitSet[1] |= 1 << 7 + requiredBitSet[2] |= 1 << 0 if err := func() error { v, err := d.Int64() s.EndLt = int64(v) @@ -4549,7 +5032,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"end_lt\"") } case "vert_seqno": - requiredBitSet[2] |= 1 << 0 + requiredBitSet[2] |= 1 << 1 if err := func() error { v, err := d.Int32() s.VertSeqno = int32(v) @@ -4561,7 +5044,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"vert_seqno\"") } case "gen_catchain_seqno": - requiredBitSet[2] |= 1 << 1 + requiredBitSet[2] |= 1 << 2 if err := func() error { v, err := d.Int32() s.GenCatchainSeqno = int32(v) @@ -4573,7 +5056,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"gen_catchain_seqno\"") } case "min_ref_mc_seqno": - requiredBitSet[2] |= 1 << 2 + requiredBitSet[2] |= 1 << 3 if err := func() error { v, err := d.Int32() s.MinRefMcSeqno = int32(v) @@ -4585,7 +5068,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"min_ref_mc_seqno\"") } case "prev_key_block_seqno": - requiredBitSet[2] |= 1 << 3 + requiredBitSet[2] |= 1 << 4 if err := func() error { v, err := d.Int32() s.PrevKeyBlockSeqno = int32(v) @@ -4627,7 +5110,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"master_ref\"") } case "prev_refs": - requiredBitSet[2] |= 1 << 7 + requiredBitSet[3] |= 1 << 0 if err := func() error { s.PrevRefs = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -4647,7 +5130,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"prev_refs\"") } case "in_msg_descr_length": - requiredBitSet[3] |= 1 << 0 + requiredBitSet[3] |= 1 << 1 if err := func() error { v, err := d.Int64() s.InMsgDescrLength = int64(v) @@ -4659,7 +5142,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"in_msg_descr_length\"") } case "out_msg_descr_length": - requiredBitSet[3] |= 1 << 1 + requiredBitSet[3] |= 1 << 2 if err := func() error { v, err := d.Int64() s.OutMsgDescrLength = int64(v) @@ -4671,7 +5154,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"out_msg_descr_length\"") } case "rand_seed": - requiredBitSet[3] |= 1 << 2 + requiredBitSet[3] |= 1 << 3 if err := func() error { v, err := d.Str() s.RandSeed = string(v) @@ -4683,7 +5166,7 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"rand_seed\"") } case "created_by": - requiredBitSet[3] |= 1 << 3 + requiredBitSet[3] |= 1 << 4 if err := func() error { v, err := d.Str() s.CreatedBy = string(v) @@ -4706,8 +5189,8 @@ func (s *BlockchainBlock) Decode(d *jx.Decoder) error { for i, mask := range [4]uint8{ 0b11111111, 0b11111111, - 0b10001111, - 0b00001111, + 0b00011111, + 0b00011111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -4956,17 +5439,123 @@ func (s *BlockchainBlockShardsShardsItem) UnmarshalJSON(data []byte) error { } // Encode implements json.Marshaler. -func (s *BlockchainConfig) Encode(e *jx.Encoder) { +func (s *BlockchainBlocks) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *BlockchainConfig) encodeFields(e *jx.Encoder) { +func (s *BlockchainBlocks) encodeFields(e *jx.Encoder) { { - e.FieldStart("raw") - e.Str(s.Raw) + e.FieldStart("blocks") + e.ArrStart() + for _, elem := range s.Blocks { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfBlockchainBlocks = [1]string{ + 0: "blocks", +} + +// Decode decodes BlockchainBlocks from json. +func (s *BlockchainBlocks) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BlockchainBlocks to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "blocks": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Blocks = make([]BlockchainBlock, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem BlockchainBlock + if err := elem.Decode(d); err != nil { + return err + } + s.Blocks = append(s.Blocks, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"blocks\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BlockchainBlocks") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBlockchainBlocks) { + name = jsonFieldsNameOfBlockchainBlocks[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BlockchainBlocks) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BlockchainBlocks) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BlockchainConfig) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BlockchainConfig) encodeFields(e *jx.Encoder) { + { + e.FieldStart("raw") + e.Str(s.Raw) } { e.FieldStart("0") @@ -10643,64 +11232,1115 @@ func (s *CreditPhase) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *CreditPhase) encodeFields(e *jx.Encoder) { { - e.FieldStart("fees_collected") - e.Int64(s.FeesCollected) + e.FieldStart("fees_collected") + e.Int64(s.FeesCollected) + } + { + e.FieldStart("credit") + e.Int64(s.Credit) + } +} + +var jsonFieldsNameOfCreditPhase = [2]string{ + 0: "fees_collected", + 1: "credit", +} + +// Decode decodes CreditPhase from json. +func (s *CreditPhase) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreditPhase to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "fees_collected": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.FeesCollected = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"fees_collected\"") + } + case "credit": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.Credit = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"credit\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreditPhase") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfCreditPhase) { + name = jsonFieldsNameOfCreditPhase[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CreditPhase) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreditPhase) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodeMessageReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodeMessageReq) encodeFields(e *jx.Encoder) { + { + e.FieldStart("boc") + e.Str(s.Boc) + } +} + +var jsonFieldsNameOfDecodeMessageReq = [1]string{ + 0: "boc", +} + +// Decode decodes DecodeMessageReq from json. +func (s *DecodeMessageReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodeMessageReq to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "boc": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Boc = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"boc\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DecodeMessageReq") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDecodeMessageReq) { + name = jsonFieldsNameOfDecodeMessageReq[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DecodeMessageReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodeMessageReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodedMessage) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedMessage) encodeFields(e *jx.Encoder) { + { + e.FieldStart("destination") + s.Destination.Encode(e) + } + { + e.FieldStart("destination_wallet_version") + e.Str(s.DestinationWalletVersion) + } + { + if s.ExtInMsgDecoded.Set { + e.FieldStart("ext_in_msg_decoded") + s.ExtInMsgDecoded.Encode(e) + } + } +} + +var jsonFieldsNameOfDecodedMessage = [3]string{ + 0: "destination", + 1: "destination_wallet_version", + 2: "ext_in_msg_decoded", +} + +// Decode decodes DecodedMessage from json. +func (s *DecodedMessage) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodedMessage to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "destination": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Destination.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"destination\"") + } + case "destination_wallet_version": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.DestinationWalletVersion = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"destination_wallet_version\"") + } + case "ext_in_msg_decoded": + if err := func() error { + s.ExtInMsgDecoded.Reset() + if err := s.ExtInMsgDecoded.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ext_in_msg_decoded\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DecodedMessage") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDecodedMessage) { + name = jsonFieldsNameOfDecodedMessage[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DecodedMessage) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodedMessage) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodedMessageExtInMsgDecoded) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedMessageExtInMsgDecoded) encodeFields(e *jx.Encoder) { + { + if s.WalletV3.Set { + e.FieldStart("wallet_v3") + s.WalletV3.Encode(e) + } + } + { + if s.WalletV4.Set { + e.FieldStart("wallet_v4") + s.WalletV4.Encode(e) + } + } + { + if s.WalletHighloadV2.Set { + e.FieldStart("wallet_highload_v2") + s.WalletHighloadV2.Encode(e) + } + } +} + +var jsonFieldsNameOfDecodedMessageExtInMsgDecoded = [3]string{ + 0: "wallet_v3", + 1: "wallet_v4", + 2: "wallet_highload_v2", +} + +// Decode decodes DecodedMessageExtInMsgDecoded from json. +func (s *DecodedMessageExtInMsgDecoded) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecoded to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "wallet_v3": + if err := func() error { + s.WalletV3.Reset() + if err := s.WalletV3.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_v3\"") + } + case "wallet_v4": + if err := func() error { + s.WalletV4.Reset() + if err := s.WalletV4.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_v4\"") + } + case "wallet_highload_v2": + if err := func() error { + s.WalletHighloadV2.Reset() + if err := s.WalletHighloadV2.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_highload_v2\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecoded") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DecodedMessageExtInMsgDecoded) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodedMessageExtInMsgDecoded) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) encodeFields(e *jx.Encoder) { + { + e.FieldStart("subwallet_id") + e.UInt32(s.SubwalletID) + } + { + e.FieldStart("bounded_query_id") + e.Str(s.BoundedQueryID) + } + { + e.FieldStart("raw_messages") + e.ArrStart() + for _, elem := range s.RawMessages { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2 = [3]string{ + 0: "subwallet_id", + 1: "bounded_query_id", + 2: "raw_messages", +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletHighloadV2 from json. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletHighloadV2 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "subwallet_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.UInt32() + s.SubwalletID = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"subwallet_id\"") + } + case "bounded_query_id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.BoundedQueryID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bounded_query_id\"") + } + case "raw_messages": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.RawMessages = make([]DecodedRawMessage, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem DecodedRawMessage + if err := elem.Decode(d); err != nil { + return err + } + s.RawMessages = append(s.RawMessages, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raw_messages\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletHighloadV2") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2) { + name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodedMessageExtInMsgDecodedWalletV3) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedMessageExtInMsgDecodedWalletV3) encodeFields(e *jx.Encoder) { + { + e.FieldStart("subwallet_id") + e.UInt32(s.SubwalletID) + } + { + e.FieldStart("valid_until") + e.UInt32(s.ValidUntil) + } + { + e.FieldStart("seqno") + e.UInt32(s.Seqno) + } + { + e.FieldStart("raw_messages") + e.ArrStart() + for _, elem := range s.RawMessages { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3 = [4]string{ + 0: "subwallet_id", + 1: "valid_until", + 2: "seqno", + 3: "raw_messages", +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletV3 from json. +func (s *DecodedMessageExtInMsgDecodedWalletV3) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletV3 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "subwallet_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.UInt32() + s.SubwalletID = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"subwallet_id\"") + } + case "valid_until": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.UInt32() + s.ValidUntil = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"valid_until\"") + } + case "seqno": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.UInt32() + s.Seqno = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"seqno\"") + } + case "raw_messages": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + s.RawMessages = make([]DecodedRawMessage, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem DecodedRawMessage + if err := elem.Decode(d); err != nil { + return err + } + s.RawMessages = append(s.RawMessages, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raw_messages\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletV3") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3) { + name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DecodedMessageExtInMsgDecodedWalletV3) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodedMessageExtInMsgDecodedWalletV3) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodedMessageExtInMsgDecodedWalletV4) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedMessageExtInMsgDecodedWalletV4) encodeFields(e *jx.Encoder) { + { + e.FieldStart("subwallet_id") + e.UInt32(s.SubwalletID) + } + { + e.FieldStart("valid_until") + e.UInt32(s.ValidUntil) + } + { + e.FieldStart("seqno") + e.UInt32(s.Seqno) + } + { + e.FieldStart("op") + e.Int8(s.Op) + } + { + e.FieldStart("raw_messages") + e.ArrStart() + for _, elem := range s.RawMessages { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4 = [5]string{ + 0: "subwallet_id", + 1: "valid_until", + 2: "seqno", + 3: "op", + 4: "raw_messages", +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletV4 from json. +func (s *DecodedMessageExtInMsgDecodedWalletV4) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletV4 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "subwallet_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.UInt32() + s.SubwalletID = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"subwallet_id\"") + } + case "valid_until": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.UInt32() + s.ValidUntil = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"valid_until\"") + } + case "seqno": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.UInt32() + s.Seqno = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"seqno\"") + } + case "op": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int8() + s.Op = int8(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"op\"") + } + case "raw_messages": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + s.RawMessages = make([]DecodedRawMessage, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem DecodedRawMessage + if err := elem.Decode(d); err != nil { + return err + } + s.RawMessages = append(s.RawMessages, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raw_messages\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletV4") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4) { + name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DecodedMessageExtInMsgDecodedWalletV4) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodedMessageExtInMsgDecodedWalletV4) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodedRawMessage) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedRawMessage) encodeFields(e *jx.Encoder) { + { + e.FieldStart("message") + s.Message.Encode(e) + } + { + e.FieldStart("mode") + e.Int(s.Mode) + } +} + +var jsonFieldsNameOfDecodedRawMessage = [2]string{ + 0: "message", + 1: "mode", +} + +// Decode decodes DecodedRawMessage from json. +func (s *DecodedRawMessage) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodedRawMessage to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "message": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Message.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"message\"") + } + case "mode": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Mode = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mode\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DecodedRawMessage") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDecodedRawMessage) { + name = jsonFieldsNameOfDecodedRawMessage[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DecodedRawMessage) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodedRawMessage) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodedRawMessageMessage) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedRawMessageMessage) encodeFields(e *jx.Encoder) { + { + e.FieldStart("boc") + e.Str(s.Boc) + } + { + if s.DecodedOpName.Set { + e.FieldStart("decoded_op_name") + s.DecodedOpName.Encode(e) + } + } + { + if s.OpCode.Set { + e.FieldStart("op_code") + s.OpCode.Encode(e) + } } { - e.FieldStart("credit") - e.Int64(s.Credit) + if len(s.DecodedBody) != 0 { + e.FieldStart("decoded_body") + e.Raw(s.DecodedBody) + } } } -var jsonFieldsNameOfCreditPhase = [2]string{ - 0: "fees_collected", - 1: "credit", +var jsonFieldsNameOfDecodedRawMessageMessage = [4]string{ + 0: "boc", + 1: "decoded_op_name", + 2: "op_code", + 3: "decoded_body", } -// Decode decodes CreditPhase from json. -func (s *CreditPhase) Decode(d *jx.Decoder) error { +// Decode decodes DecodedRawMessageMessage from json. +func (s *DecodedRawMessageMessage) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode CreditPhase to nil") + return errors.New("invalid: unable to decode DecodedRawMessageMessage to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "fees_collected": + case "boc": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.FeesCollected = int64(v) + v, err := d.Str() + s.Boc = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"fees_collected\"") + return errors.Wrap(err, "decode field \"boc\"") } - case "credit": - requiredBitSet[0] |= 1 << 1 + case "decoded_op_name": if err := func() error { - v, err := d.Int64() - s.Credit = int64(v) + s.DecodedOpName.Reset() + if err := s.DecodedOpName.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"decoded_op_name\"") + } + case "op_code": + if err := func() error { + s.OpCode.Reset() + if err := s.OpCode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"op_code\"") + } + case "decoded_body": + if err := func() error { + v, err := d.RawAppend(nil) + s.DecodedBody = jx.Raw(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"credit\"") + return errors.Wrap(err, "decode field \"decoded_body\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode CreditPhase") + return errors.Wrap(err, "decode DecodedRawMessageMessage") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -10712,8 +12352,8 @@ func (s *CreditPhase) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfCreditPhase) { - name = jsonFieldsNameOfCreditPhase[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodedRawMessageMessage) { + name = jsonFieldsNameOfDecodedRawMessageMessage[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -10734,14 +12374,14 @@ func (s *CreditPhase) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *CreditPhase) MarshalJSON() ([]byte, error) { +func (s *DecodedRawMessageMessage) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *CreditPhase) UnmarshalJSON(data []byte) error { +func (s *DecodedRawMessageMessage) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } @@ -20727,6 +22367,10 @@ func (s *Message) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *Message) encodeFields(e *jx.Encoder) { + { + e.FieldStart("msg_type") + s.MsgType.Encode(e) + } { e.FieldStart("created_lt") e.Int64(s.CreatedLt) @@ -20807,23 +22451,24 @@ func (s *Message) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfMessage = [16]string{ - 0: "created_lt", - 1: "ihr_disabled", - 2: "bounce", - 3: "bounced", - 4: "value", - 5: "fwd_fee", - 6: "ihr_fee", - 7: "destination", - 8: "source", - 9: "import_fee", - 10: "created_at", - 11: "op_code", - 12: "init", - 13: "raw_body", - 14: "decoded_op_name", - 15: "decoded_body", +var jsonFieldsNameOfMessage = [17]string{ + 0: "msg_type", + 1: "created_lt", + 2: "ihr_disabled", + 3: "bounce", + 4: "bounced", + 5: "value", + 6: "fwd_fee", + 7: "ihr_fee", + 8: "destination", + 9: "source", + 10: "import_fee", + 11: "created_at", + 12: "op_code", + 13: "init", + 14: "raw_body", + 15: "decoded_op_name", + 16: "decoded_body", } // Decode decodes Message from json. @@ -20831,12 +22476,22 @@ func (s *Message) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode Message to nil") } - var requiredBitSet [2]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "created_lt": + case "msg_type": requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.MsgType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"msg_type\"") + } + case "created_lt": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Int64() s.CreatedLt = int64(v) @@ -20848,7 +22503,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"created_lt\"") } case "ihr_disabled": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Bool() s.IhrDisabled = bool(v) @@ -20860,7 +22515,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"ihr_disabled\"") } case "bounce": - requiredBitSet[0] |= 1 << 2 + requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Bool() s.Bounce = bool(v) @@ -20872,7 +22527,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"bounce\"") } case "bounced": - requiredBitSet[0] |= 1 << 3 + requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Bool() s.Bounced = bool(v) @@ -20884,7 +22539,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"bounced\"") } case "value": - requiredBitSet[0] |= 1 << 4 + requiredBitSet[0] |= 1 << 5 if err := func() error { v, err := d.Int64() s.Value = int64(v) @@ -20896,7 +22551,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"value\"") } case "fwd_fee": - requiredBitSet[0] |= 1 << 5 + requiredBitSet[0] |= 1 << 6 if err := func() error { v, err := d.Int64() s.FwdFee = int64(v) @@ -20908,7 +22563,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"fwd_fee\"") } case "ihr_fee": - requiredBitSet[0] |= 1 << 6 + requiredBitSet[0] |= 1 << 7 if err := func() error { v, err := d.Int64() s.IhrFee = int64(v) @@ -20940,7 +22595,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"source\"") } case "import_fee": - requiredBitSet[1] |= 1 << 1 + requiredBitSet[1] |= 1 << 2 if err := func() error { v, err := d.Int64() s.ImportFee = int64(v) @@ -20952,7 +22607,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"import_fee\"") } case "created_at": - requiredBitSet[1] |= 1 << 2 + requiredBitSet[1] |= 1 << 3 if err := func() error { v, err := d.Int64() s.CreatedAt = int64(v) @@ -21023,9 +22678,10 @@ func (s *Message) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b01111111, - 0b00000110, + for i, mask := range [3]uint8{ + 0b11111111, + 0b00001100, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -21195,6 +22851,48 @@ func (s *MessageConsequences) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes MessageMsgType as json. +func (s MessageMsgType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes MessageMsgType from json. +func (s *MessageMsgType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MessageMsgType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch MessageMsgType(v) { + case MessageMsgTypeIntMsg: + *s = MessageMsgTypeIntMsg + case MessageMsgTypeExtInMsg: + *s = MessageMsgTypeExtInMsg + case MessageMsgTypeExtOutMsg: + *s = MessageMsgTypeExtOutMsg + default: + *s = MessageMsgType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s MessageMsgType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MessageMsgType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *MethodExecutionResult) Encode(e *jx.Encoder) { e.ObjStart() @@ -23308,6 +25006,39 @@ func (s *OptAuctionBidAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes BlockCurrencyCollection as json. +func (o OptBlockCurrencyCollection) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes BlockCurrencyCollection from json. +func (o *OptBlockCurrencyCollection) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptBlockCurrencyCollection to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptBlockCurrencyCollection) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptBlockCurrencyCollection) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes BlockchainAccountInspectCompiler as json. func (o OptBlockchainAccountInspectCompiler) Encode(e *jx.Encoder) { if !o.Set { @@ -24598,6 +26329,138 @@ func (s *OptCreditPhase) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes DecodedMessageExtInMsgDecoded as json. +func (o OptDecodedMessageExtInMsgDecoded) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes DecodedMessageExtInMsgDecoded from json. +func (o *OptDecodedMessageExtInMsgDecoded) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptDecodedMessageExtInMsgDecoded to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDecodedMessageExtInMsgDecoded) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDecodedMessageExtInMsgDecoded) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes DecodedMessageExtInMsgDecodedWalletHighloadV2 as json. +func (o OptDecodedMessageExtInMsgDecodedWalletHighloadV2) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletHighloadV2 from json. +func (o *OptDecodedMessageExtInMsgDecodedWalletHighloadV2) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptDecodedMessageExtInMsgDecodedWalletHighloadV2 to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDecodedMessageExtInMsgDecodedWalletHighloadV2) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDecodedMessageExtInMsgDecodedWalletHighloadV2) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes DecodedMessageExtInMsgDecodedWalletV3 as json. +func (o OptDecodedMessageExtInMsgDecodedWalletV3) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletV3 from json. +func (o *OptDecodedMessageExtInMsgDecodedWalletV3) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptDecodedMessageExtInMsgDecodedWalletV3 to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDecodedMessageExtInMsgDecodedWalletV3) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDecodedMessageExtInMsgDecodedWalletV3) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes DecodedMessageExtInMsgDecodedWalletV4 as json. +func (o OptDecodedMessageExtInMsgDecodedWalletV4) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletV4 from json. +func (o *OptDecodedMessageExtInMsgDecodedWalletV4) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptDecodedMessageExtInMsgDecodedWalletV4 to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDecodedMessageExtInMsgDecodedWalletV4) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDecodedMessageExtInMsgDecodedWalletV4) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes DepositStakeAction as json. func (o OptDepositStakeAction) Encode(e *jx.Encoder) { if !o.Set { diff --git a/oas_parameters_gen.go b/oas_parameters_gen.go index 059322d..1bd1b16 100644 --- a/oas_parameters_gen.go +++ b/oas_parameters_gen.go @@ -238,12 +238,24 @@ type GetBlockchainConfigFromBlockParams struct { MasterchainSeqno int32 } +// GetBlockchainMasterchainBlocksParams is parameters of getBlockchainMasterchainBlocks operation. +type GetBlockchainMasterchainBlocksParams struct { + // Masterchain block seqno. + MasterchainSeqno int32 +} + // GetBlockchainMasterchainShardsParams is parameters of getBlockchainMasterchainShards operation. type GetBlockchainMasterchainShardsParams struct { // Masterchain block seqno. MasterchainSeqno int32 } +// GetBlockchainMasterchainTransactionsParams is parameters of getBlockchainMasterchainTransactions operation. +type GetBlockchainMasterchainTransactionsParams struct { + // Masterchain block seqno. + MasterchainSeqno int32 +} + // GetBlockchainRawAccountParams is parameters of getBlockchainRawAccount operation. type GetBlockchainRawAccountParams struct { // Account ID. diff --git a/oas_request_encoders_gen.go b/oas_request_encoders_gen.go index 6b3071a..ffdb67e 100644 --- a/oas_request_encoders_gen.go +++ b/oas_request_encoders_gen.go @@ -11,6 +11,20 @@ import ( ht "github.com/ogen-go/ogen/http" ) +func encodeDecodeMessageRequest( + req *DecodeMessageReq, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + func encodeEmulateMessageToAccountEventRequest( req *EmulateMessageToAccountEventReq, r *http.Request, diff --git a/oas_response_decoders_gen.go b/oas_response_decoders_gen.go index 7df9340..e163eb0 100644 --- a/oas_response_decoders_gen.go +++ b/oas_response_decoders_gen.go @@ -263,6 +263,89 @@ func decodeBlockchainAccountInspectResponse(resp *http.Response) (res *Blockchai return res, errors.Wrap(defRes, "error") } +func decodeDecodeMessageResponse(resp *http.Response) (res *DecodedMessage, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DecodedMessage + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + // Convenient error response. + defRes, err := func() (res *ErrorStatusCode, err error) { + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &ErrorStatusCode{ + StatusCode: resp.StatusCode, + Response: response, + }, nil + default: + return res, validate.InvalidContentType(ct) + } + }() + if err != nil { + return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode) + } + return res, errors.Wrap(defRes, "error") +} + func decodeDnsResolveResponse(resp *http.Response) (res *DnsRecord, _ error) { switch resp.StatusCode { case 200: @@ -2753,6 +2836,89 @@ func decodeGetBlockchainConfigFromBlockResponse(resp *http.Response) (res *Block return res, errors.Wrap(defRes, "error") } +func decodeGetBlockchainMasterchainBlocksResponse(resp *http.Response) (res *BlockchainBlocks, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BlockchainBlocks + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + // Convenient error response. + defRes, err := func() (res *ErrorStatusCode, err error) { + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &ErrorStatusCode{ + StatusCode: resp.StatusCode, + Response: response, + }, nil + default: + return res, validate.InvalidContentType(ct) + } + }() + if err != nil { + return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode) + } + return res, errors.Wrap(defRes, "error") +} + func decodeGetBlockchainMasterchainHeadResponse(resp *http.Response) (res *BlockchainBlock, _ error) { switch resp.StatusCode { case 200: @@ -2919,6 +3085,89 @@ func decodeGetBlockchainMasterchainShardsResponse(resp *http.Response) (res *Blo return res, errors.Wrap(defRes, "error") } +func decodeGetBlockchainMasterchainTransactionsResponse(resp *http.Response) (res *Transactions, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Transactions + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + // Convenient error response. + defRes, err := func() (res *ErrorStatusCode, err error) { + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &ErrorStatusCode{ + StatusCode: resp.StatusCode, + Response: response, + }, nil + default: + return res, validate.InvalidContentType(ct) + } + }() + if err != nil { + return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode) + } + return res, errors.Wrap(defRes, "error") +} + func decodeGetBlockchainRawAccountResponse(resp *http.Response) (res *BlockchainRawAccount, _ error) { switch resp.StatusCode { case 200: diff --git a/oas_schemas_gen.go b/oas_schemas_gen.go index 1f37b23..82e464f 100644 --- a/oas_schemas_gen.go +++ b/oas_schemas_gen.go @@ -1519,6 +1519,57 @@ func (s *Auctions) SetTotal(val int64) { s.Total = val } +// Ref: #/components/schemas/BlockCurrencyCollection +type BlockCurrencyCollection struct { + Grams int64 `json:"grams"` + Other []BlockCurrencyCollectionOtherItem `json:"other"` +} + +// GetGrams returns the value of Grams. +func (s *BlockCurrencyCollection) GetGrams() int64 { + return s.Grams +} + +// GetOther returns the value of Other. +func (s *BlockCurrencyCollection) GetOther() []BlockCurrencyCollectionOtherItem { + return s.Other +} + +// SetGrams sets the value of Grams. +func (s *BlockCurrencyCollection) SetGrams(val int64) { + s.Grams = val +} + +// SetOther sets the value of Other. +func (s *BlockCurrencyCollection) SetOther(val []BlockCurrencyCollectionOtherItem) { + s.Other = val +} + +type BlockCurrencyCollectionOtherItem struct { + ID int64 `json:"id"` + Value string `json:"value"` +} + +// GetID returns the value of ID. +func (s *BlockCurrencyCollectionOtherItem) GetID() int64 { + return s.ID +} + +// GetValue returns the value of Value. +func (s *BlockCurrencyCollectionOtherItem) GetValue() string { + return s.Value +} + +// SetID sets the value of ID. +func (s *BlockCurrencyCollectionOtherItem) SetID(val int64) { + s.ID = val +} + +// SetValue sets the value of Value. +func (s *BlockCurrencyCollectionOtherItem) SetValue(val string) { + s.Value = val +} + // Ref: #/components/schemas/BlockLimits type BlockLimits struct { Bytes BlockParamLimits `json:"bytes"` @@ -1652,6 +1703,120 @@ func (s *BlockRaw) SetFileHash(val string) { s.FileHash = val } +// Ref: #/components/schemas/BlockValueFlow +type BlockValueFlow struct { + FromPrevBlk BlockCurrencyCollection `json:"from_prev_blk"` + ToNextBlk BlockCurrencyCollection `json:"to_next_blk"` + Imported BlockCurrencyCollection `json:"imported"` + Exported BlockCurrencyCollection `json:"exported"` + FeesCollected BlockCurrencyCollection `json:"fees_collected"` + Burned OptBlockCurrencyCollection `json:"burned"` + FeesImported BlockCurrencyCollection `json:"fees_imported"` + Recovered BlockCurrencyCollection `json:"recovered"` + Created BlockCurrencyCollection `json:"created"` + Minted BlockCurrencyCollection `json:"minted"` +} + +// GetFromPrevBlk returns the value of FromPrevBlk. +func (s *BlockValueFlow) GetFromPrevBlk() BlockCurrencyCollection { + return s.FromPrevBlk +} + +// GetToNextBlk returns the value of ToNextBlk. +func (s *BlockValueFlow) GetToNextBlk() BlockCurrencyCollection { + return s.ToNextBlk +} + +// GetImported returns the value of Imported. +func (s *BlockValueFlow) GetImported() BlockCurrencyCollection { + return s.Imported +} + +// GetExported returns the value of Exported. +func (s *BlockValueFlow) GetExported() BlockCurrencyCollection { + return s.Exported +} + +// GetFeesCollected returns the value of FeesCollected. +func (s *BlockValueFlow) GetFeesCollected() BlockCurrencyCollection { + return s.FeesCollected +} + +// GetBurned returns the value of Burned. +func (s *BlockValueFlow) GetBurned() OptBlockCurrencyCollection { + return s.Burned +} + +// GetFeesImported returns the value of FeesImported. +func (s *BlockValueFlow) GetFeesImported() BlockCurrencyCollection { + return s.FeesImported +} + +// GetRecovered returns the value of Recovered. +func (s *BlockValueFlow) GetRecovered() BlockCurrencyCollection { + return s.Recovered +} + +// GetCreated returns the value of Created. +func (s *BlockValueFlow) GetCreated() BlockCurrencyCollection { + return s.Created +} + +// GetMinted returns the value of Minted. +func (s *BlockValueFlow) GetMinted() BlockCurrencyCollection { + return s.Minted +} + +// SetFromPrevBlk sets the value of FromPrevBlk. +func (s *BlockValueFlow) SetFromPrevBlk(val BlockCurrencyCollection) { + s.FromPrevBlk = val +} + +// SetToNextBlk sets the value of ToNextBlk. +func (s *BlockValueFlow) SetToNextBlk(val BlockCurrencyCollection) { + s.ToNextBlk = val +} + +// SetImported sets the value of Imported. +func (s *BlockValueFlow) SetImported(val BlockCurrencyCollection) { + s.Imported = val +} + +// SetExported sets the value of Exported. +func (s *BlockValueFlow) SetExported(val BlockCurrencyCollection) { + s.Exported = val +} + +// SetFeesCollected sets the value of FeesCollected. +func (s *BlockValueFlow) SetFeesCollected(val BlockCurrencyCollection) { + s.FeesCollected = val +} + +// SetBurned sets the value of Burned. +func (s *BlockValueFlow) SetBurned(val OptBlockCurrencyCollection) { + s.Burned = val +} + +// SetFeesImported sets the value of FeesImported. +func (s *BlockValueFlow) SetFeesImported(val BlockCurrencyCollection) { + s.FeesImported = val +} + +// SetRecovered sets the value of Recovered. +func (s *BlockValueFlow) SetRecovered(val BlockCurrencyCollection) { + s.Recovered = val +} + +// SetCreated sets the value of Created. +func (s *BlockValueFlow) SetCreated(val BlockCurrencyCollection) { + s.Created = val +} + +// SetMinted sets the value of Minted. +func (s *BlockValueFlow) SetMinted(val BlockCurrencyCollection) { + s.Minted = val +} + // Ref: #/components/schemas/BlockchainAccountInspect type BlockchainAccountInspect struct { Code string `json:"code"` @@ -1761,34 +1926,40 @@ func (s *BlockchainAccountInspectMethodsItem) SetMethod(val string) { // Ref: #/components/schemas/BlockchainBlock type BlockchainBlock struct { - WorkchainID int32 `json:"workchain_id"` - Shard string `json:"shard"` - Seqno int32 `json:"seqno"` - RootHash string `json:"root_hash"` - FileHash string `json:"file_hash"` - GlobalID int32 `json:"global_id"` - Version int32 `json:"version"` - AfterMerge bool `json:"after_merge"` - BeforeSplit bool `json:"before_split"` - AfterSplit bool `json:"after_split"` - WantSplit bool `json:"want_split"` - WantMerge bool `json:"want_merge"` - KeyBlock bool `json:"key_block"` - GenUtime int64 `json:"gen_utime"` - StartLt int64 `json:"start_lt"` - EndLt int64 `json:"end_lt"` - VertSeqno int32 `json:"vert_seqno"` - GenCatchainSeqno int32 `json:"gen_catchain_seqno"` - MinRefMcSeqno int32 `json:"min_ref_mc_seqno"` - PrevKeyBlockSeqno int32 `json:"prev_key_block_seqno"` - GenSoftwareVersion OptInt32 `json:"gen_software_version"` - GenSoftwareCapabilities OptInt64 `json:"gen_software_capabilities"` - MasterRef OptString `json:"master_ref"` - PrevRefs []string `json:"prev_refs"` - InMsgDescrLength int64 `json:"in_msg_descr_length"` - OutMsgDescrLength int64 `json:"out_msg_descr_length"` - RandSeed string `json:"rand_seed"` - CreatedBy string `json:"created_by"` + ValueFlow BlockValueFlow `json:"value_flow"` + WorkchainID int32 `json:"workchain_id"` + Shard string `json:"shard"` + Seqno int32 `json:"seqno"` + RootHash string `json:"root_hash"` + FileHash string `json:"file_hash"` + GlobalID int32 `json:"global_id"` + Version int32 `json:"version"` + AfterMerge bool `json:"after_merge"` + BeforeSplit bool `json:"before_split"` + AfterSplit bool `json:"after_split"` + WantSplit bool `json:"want_split"` + WantMerge bool `json:"want_merge"` + KeyBlock bool `json:"key_block"` + GenUtime int64 `json:"gen_utime"` + StartLt int64 `json:"start_lt"` + EndLt int64 `json:"end_lt"` + VertSeqno int32 `json:"vert_seqno"` + GenCatchainSeqno int32 `json:"gen_catchain_seqno"` + MinRefMcSeqno int32 `json:"min_ref_mc_seqno"` + PrevKeyBlockSeqno int32 `json:"prev_key_block_seqno"` + GenSoftwareVersion OptInt32 `json:"gen_software_version"` + GenSoftwareCapabilities OptInt64 `json:"gen_software_capabilities"` + MasterRef OptString `json:"master_ref"` + PrevRefs []string `json:"prev_refs"` + InMsgDescrLength int64 `json:"in_msg_descr_length"` + OutMsgDescrLength int64 `json:"out_msg_descr_length"` + RandSeed string `json:"rand_seed"` + CreatedBy string `json:"created_by"` +} + +// GetValueFlow returns the value of ValueFlow. +func (s *BlockchainBlock) GetValueFlow() BlockValueFlow { + return s.ValueFlow } // GetWorkchainID returns the value of WorkchainID. @@ -1931,6 +2102,11 @@ func (s *BlockchainBlock) GetCreatedBy() string { return s.CreatedBy } +// SetValueFlow sets the value of ValueFlow. +func (s *BlockchainBlock) SetValueFlow(val BlockValueFlow) { + s.ValueFlow = val +} + // SetWorkchainID sets the value of WorkchainID. func (s *BlockchainBlock) SetWorkchainID(val int32) { s.WorkchainID = val @@ -2100,6 +2276,21 @@ func (s *BlockchainBlockShardsShardsItem) SetLastKnownBlockID(val string) { s.LastKnownBlockID = val } +// Ref: #/components/schemas/BlockchainBlocks +type BlockchainBlocks struct { + Blocks []BlockchainBlock `json:"blocks"` +} + +// GetBlocks returns the value of Blocks. +func (s *BlockchainBlocks) GetBlocks() []BlockchainBlock { + return s.Blocks +} + +// SetBlocks sets the value of Blocks. +func (s *BlockchainBlocks) SetBlocks(val []BlockchainBlock) { + s.Blocks = val +} + // Ref: #/components/schemas/BlockchainConfig type BlockchainConfig struct { // Config boc in base64 format. @@ -3990,6 +4181,307 @@ func (s *CreditPhase) SetCredit(val int64) { s.Credit = val } +type DecodeMessageReq struct { + Boc string `json:"boc"` +} + +// GetBoc returns the value of Boc. +func (s *DecodeMessageReq) GetBoc() string { + return s.Boc +} + +// SetBoc sets the value of Boc. +func (s *DecodeMessageReq) SetBoc(val string) { + s.Boc = val +} + +// Ref: #/components/schemas/DecodedMessage +type DecodedMessage struct { + Destination AccountAddress `json:"destination"` + DestinationWalletVersion string `json:"destination_wallet_version"` + ExtInMsgDecoded OptDecodedMessageExtInMsgDecoded `json:"ext_in_msg_decoded"` +} + +// GetDestination returns the value of Destination. +func (s *DecodedMessage) GetDestination() AccountAddress { + return s.Destination +} + +// GetDestinationWalletVersion returns the value of DestinationWalletVersion. +func (s *DecodedMessage) GetDestinationWalletVersion() string { + return s.DestinationWalletVersion +} + +// GetExtInMsgDecoded returns the value of ExtInMsgDecoded. +func (s *DecodedMessage) GetExtInMsgDecoded() OptDecodedMessageExtInMsgDecoded { + return s.ExtInMsgDecoded +} + +// SetDestination sets the value of Destination. +func (s *DecodedMessage) SetDestination(val AccountAddress) { + s.Destination = val +} + +// SetDestinationWalletVersion sets the value of DestinationWalletVersion. +func (s *DecodedMessage) SetDestinationWalletVersion(val string) { + s.DestinationWalletVersion = val +} + +// SetExtInMsgDecoded sets the value of ExtInMsgDecoded. +func (s *DecodedMessage) SetExtInMsgDecoded(val OptDecodedMessageExtInMsgDecoded) { + s.ExtInMsgDecoded = val +} + +type DecodedMessageExtInMsgDecoded struct { + WalletV3 OptDecodedMessageExtInMsgDecodedWalletV3 `json:"wallet_v3"` + WalletV4 OptDecodedMessageExtInMsgDecodedWalletV4 `json:"wallet_v4"` + WalletHighloadV2 OptDecodedMessageExtInMsgDecodedWalletHighloadV2 `json:"wallet_highload_v2"` +} + +// GetWalletV3 returns the value of WalletV3. +func (s *DecodedMessageExtInMsgDecoded) GetWalletV3() OptDecodedMessageExtInMsgDecodedWalletV3 { + return s.WalletV3 +} + +// GetWalletV4 returns the value of WalletV4. +func (s *DecodedMessageExtInMsgDecoded) GetWalletV4() OptDecodedMessageExtInMsgDecodedWalletV4 { + return s.WalletV4 +} + +// GetWalletHighloadV2 returns the value of WalletHighloadV2. +func (s *DecodedMessageExtInMsgDecoded) GetWalletHighloadV2() OptDecodedMessageExtInMsgDecodedWalletHighloadV2 { + return s.WalletHighloadV2 +} + +// SetWalletV3 sets the value of WalletV3. +func (s *DecodedMessageExtInMsgDecoded) SetWalletV3(val OptDecodedMessageExtInMsgDecodedWalletV3) { + s.WalletV3 = val +} + +// SetWalletV4 sets the value of WalletV4. +func (s *DecodedMessageExtInMsgDecoded) SetWalletV4(val OptDecodedMessageExtInMsgDecodedWalletV4) { + s.WalletV4 = val +} + +// SetWalletHighloadV2 sets the value of WalletHighloadV2. +func (s *DecodedMessageExtInMsgDecoded) SetWalletHighloadV2(val OptDecodedMessageExtInMsgDecodedWalletHighloadV2) { + s.WalletHighloadV2 = val +} + +type DecodedMessageExtInMsgDecodedWalletHighloadV2 struct { + SubwalletID uint32 `json:"subwallet_id"` + BoundedQueryID string `json:"bounded_query_id"` + RawMessages []DecodedRawMessage `json:"raw_messages"` +} + +// GetSubwalletID returns the value of SubwalletID. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) GetSubwalletID() uint32 { + return s.SubwalletID +} + +// GetBoundedQueryID returns the value of BoundedQueryID. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) GetBoundedQueryID() string { + return s.BoundedQueryID +} + +// GetRawMessages returns the value of RawMessages. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) GetRawMessages() []DecodedRawMessage { + return s.RawMessages +} + +// SetSubwalletID sets the value of SubwalletID. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) SetSubwalletID(val uint32) { + s.SubwalletID = val +} + +// SetBoundedQueryID sets the value of BoundedQueryID. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) SetBoundedQueryID(val string) { + s.BoundedQueryID = val +} + +// SetRawMessages sets the value of RawMessages. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) SetRawMessages(val []DecodedRawMessage) { + s.RawMessages = val +} + +type DecodedMessageExtInMsgDecodedWalletV3 struct { + SubwalletID uint32 `json:"subwallet_id"` + ValidUntil uint32 `json:"valid_until"` + Seqno uint32 `json:"seqno"` + RawMessages []DecodedRawMessage `json:"raw_messages"` +} + +// GetSubwalletID returns the value of SubwalletID. +func (s *DecodedMessageExtInMsgDecodedWalletV3) GetSubwalletID() uint32 { + return s.SubwalletID +} + +// GetValidUntil returns the value of ValidUntil. +func (s *DecodedMessageExtInMsgDecodedWalletV3) GetValidUntil() uint32 { + return s.ValidUntil +} + +// GetSeqno returns the value of Seqno. +func (s *DecodedMessageExtInMsgDecodedWalletV3) GetSeqno() uint32 { + return s.Seqno +} + +// GetRawMessages returns the value of RawMessages. +func (s *DecodedMessageExtInMsgDecodedWalletV3) GetRawMessages() []DecodedRawMessage { + return s.RawMessages +} + +// SetSubwalletID sets the value of SubwalletID. +func (s *DecodedMessageExtInMsgDecodedWalletV3) SetSubwalletID(val uint32) { + s.SubwalletID = val +} + +// SetValidUntil sets the value of ValidUntil. +func (s *DecodedMessageExtInMsgDecodedWalletV3) SetValidUntil(val uint32) { + s.ValidUntil = val +} + +// SetSeqno sets the value of Seqno. +func (s *DecodedMessageExtInMsgDecodedWalletV3) SetSeqno(val uint32) { + s.Seqno = val +} + +// SetRawMessages sets the value of RawMessages. +func (s *DecodedMessageExtInMsgDecodedWalletV3) SetRawMessages(val []DecodedRawMessage) { + s.RawMessages = val +} + +type DecodedMessageExtInMsgDecodedWalletV4 struct { + SubwalletID uint32 `json:"subwallet_id"` + ValidUntil uint32 `json:"valid_until"` + Seqno uint32 `json:"seqno"` + Op int8 `json:"op"` + RawMessages []DecodedRawMessage `json:"raw_messages"` +} + +// GetSubwalletID returns the value of SubwalletID. +func (s *DecodedMessageExtInMsgDecodedWalletV4) GetSubwalletID() uint32 { + return s.SubwalletID +} + +// GetValidUntil returns the value of ValidUntil. +func (s *DecodedMessageExtInMsgDecodedWalletV4) GetValidUntil() uint32 { + return s.ValidUntil +} + +// GetSeqno returns the value of Seqno. +func (s *DecodedMessageExtInMsgDecodedWalletV4) GetSeqno() uint32 { + return s.Seqno +} + +// GetOp returns the value of Op. +func (s *DecodedMessageExtInMsgDecodedWalletV4) GetOp() int8 { + return s.Op +} + +// GetRawMessages returns the value of RawMessages. +func (s *DecodedMessageExtInMsgDecodedWalletV4) GetRawMessages() []DecodedRawMessage { + return s.RawMessages +} + +// SetSubwalletID sets the value of SubwalletID. +func (s *DecodedMessageExtInMsgDecodedWalletV4) SetSubwalletID(val uint32) { + s.SubwalletID = val +} + +// SetValidUntil sets the value of ValidUntil. +func (s *DecodedMessageExtInMsgDecodedWalletV4) SetValidUntil(val uint32) { + s.ValidUntil = val +} + +// SetSeqno sets the value of Seqno. +func (s *DecodedMessageExtInMsgDecodedWalletV4) SetSeqno(val uint32) { + s.Seqno = val +} + +// SetOp sets the value of Op. +func (s *DecodedMessageExtInMsgDecodedWalletV4) SetOp(val int8) { + s.Op = val +} + +// SetRawMessages sets the value of RawMessages. +func (s *DecodedMessageExtInMsgDecodedWalletV4) SetRawMessages(val []DecodedRawMessage) { + s.RawMessages = val +} + +// Ref: #/components/schemas/DecodedRawMessage +type DecodedRawMessage struct { + Message DecodedRawMessageMessage `json:"message"` + Mode int `json:"mode"` +} + +// GetMessage returns the value of Message. +func (s *DecodedRawMessage) GetMessage() DecodedRawMessageMessage { + return s.Message +} + +// GetMode returns the value of Mode. +func (s *DecodedRawMessage) GetMode() int { + return s.Mode +} + +// SetMessage sets the value of Message. +func (s *DecodedRawMessage) SetMessage(val DecodedRawMessageMessage) { + s.Message = val +} + +// SetMode sets the value of Mode. +func (s *DecodedRawMessage) SetMode(val int) { + s.Mode = val +} + +type DecodedRawMessageMessage struct { + Boc string `json:"boc"` + DecodedOpName OptString `json:"decoded_op_name"` + OpCode OptString `json:"op_code"` + DecodedBody jx.Raw `json:"decoded_body"` +} + +// GetBoc returns the value of Boc. +func (s *DecodedRawMessageMessage) GetBoc() string { + return s.Boc +} + +// GetDecodedOpName returns the value of DecodedOpName. +func (s *DecodedRawMessageMessage) GetDecodedOpName() OptString { + return s.DecodedOpName +} + +// GetOpCode returns the value of OpCode. +func (s *DecodedRawMessageMessage) GetOpCode() OptString { + return s.OpCode +} + +// GetDecodedBody returns the value of DecodedBody. +func (s *DecodedRawMessageMessage) GetDecodedBody() jx.Raw { + return s.DecodedBody +} + +// SetBoc sets the value of Boc. +func (s *DecodedRawMessageMessage) SetBoc(val string) { + s.Boc = val +} + +// SetDecodedOpName sets the value of DecodedOpName. +func (s *DecodedRawMessageMessage) SetDecodedOpName(val OptString) { + s.DecodedOpName = val +} + +// SetOpCode sets the value of OpCode. +func (s *DecodedRawMessageMessage) SetOpCode(val OptString) { + s.OpCode = val +} + +// SetDecodedBody sets the value of DecodedBody. +func (s *DecodedRawMessageMessage) SetDecodedBody(val jx.Raw) { + s.DecodedBody = val +} + // Validator's participation in elections. // Ref: #/components/schemas/DepositStakeAction type DepositStakeAction struct { @@ -6881,6 +7373,7 @@ func (s *JettonsBalances) SetBalances(val []JettonBalance) { // Ref: #/components/schemas/Message type Message struct { + MsgType MessageMsgType `json:"msg_type"` CreatedLt int64 `json:"created_lt"` IhrDisabled bool `json:"ihr_disabled"` Bounce bool `json:"bounce"` @@ -6900,6 +7393,11 @@ type Message struct { DecodedBody jx.Raw `json:"decoded_body"` } +// GetMsgType returns the value of MsgType. +func (s *Message) GetMsgType() MessageMsgType { + return s.MsgType +} + // GetCreatedLt returns the value of CreatedLt. func (s *Message) GetCreatedLt() int64 { return s.CreatedLt @@ -6980,6 +7478,11 @@ func (s *Message) GetDecodedBody() jx.Raw { return s.DecodedBody } +// SetMsgType sets the value of MsgType. +func (s *Message) SetMsgType(val MessageMsgType) { + s.MsgType = val +} + // SetCreatedLt sets the value of CreatedLt. func (s *Message) SetCreatedLt(val int64) { s.CreatedLt = val @@ -7097,6 +7600,54 @@ func (s *MessageConsequences) SetEvent(val AccountEvent) { s.Event = val } +type MessageMsgType string + +const ( + MessageMsgTypeIntMsg MessageMsgType = "int_msg" + MessageMsgTypeExtInMsg MessageMsgType = "ext_in_msg" + MessageMsgTypeExtOutMsg MessageMsgType = "ext_out_msg" +) + +// AllValues returns all MessageMsgType values. +func (MessageMsgType) AllValues() []MessageMsgType { + return []MessageMsgType{ + MessageMsgTypeIntMsg, + MessageMsgTypeExtInMsg, + MessageMsgTypeExtOutMsg, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s MessageMsgType) MarshalText() ([]byte, error) { + switch s { + case MessageMsgTypeIntMsg: + return []byte(s), nil + case MessageMsgTypeExtInMsg: + return []byte(s), nil + case MessageMsgTypeExtOutMsg: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *MessageMsgType) UnmarshalText(data []byte) error { + switch MessageMsgType(data) { + case MessageMsgTypeIntMsg: + *s = MessageMsgTypeIntMsg + return nil + case MessageMsgTypeExtInMsg: + *s = MessageMsgTypeExtInMsg + return nil + case MessageMsgTypeExtOutMsg: + *s = MessageMsgTypeExtOutMsg + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + // Ref: #/components/schemas/MethodExecutionResult type MethodExecutionResult struct { Success bool `json:"success"` @@ -8001,6 +8552,52 @@ func (o OptAuctionBidAction) Or(d AuctionBidAction) AuctionBidAction { return d } +// NewOptBlockCurrencyCollection returns new OptBlockCurrencyCollection with value set to v. +func NewOptBlockCurrencyCollection(v BlockCurrencyCollection) OptBlockCurrencyCollection { + return OptBlockCurrencyCollection{ + Value: v, + Set: true, + } +} + +// OptBlockCurrencyCollection is optional BlockCurrencyCollection. +type OptBlockCurrencyCollection struct { + Value BlockCurrencyCollection + Set bool +} + +// IsSet returns true if OptBlockCurrencyCollection was set. +func (o OptBlockCurrencyCollection) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptBlockCurrencyCollection) Reset() { + var v BlockCurrencyCollection + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptBlockCurrencyCollection) SetTo(v BlockCurrencyCollection) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptBlockCurrencyCollection) Get() (v BlockCurrencyCollection, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptBlockCurrencyCollection) Or(d BlockCurrencyCollection) BlockCurrencyCollection { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptBlockchainAccountInspectCompiler returns new OptBlockchainAccountInspectCompiler with value set to v. func NewOptBlockchainAccountInspectCompiler(v BlockchainAccountInspectCompiler) OptBlockchainAccountInspectCompiler { return OptBlockchainAccountInspectCompiler{ @@ -9795,6 +10392,190 @@ func (o OptCreditPhase) Or(d CreditPhase) CreditPhase { return d } +// NewOptDecodedMessageExtInMsgDecoded returns new OptDecodedMessageExtInMsgDecoded with value set to v. +func NewOptDecodedMessageExtInMsgDecoded(v DecodedMessageExtInMsgDecoded) OptDecodedMessageExtInMsgDecoded { + return OptDecodedMessageExtInMsgDecoded{ + Value: v, + Set: true, + } +} + +// OptDecodedMessageExtInMsgDecoded is optional DecodedMessageExtInMsgDecoded. +type OptDecodedMessageExtInMsgDecoded struct { + Value DecodedMessageExtInMsgDecoded + Set bool +} + +// IsSet returns true if OptDecodedMessageExtInMsgDecoded was set. +func (o OptDecodedMessageExtInMsgDecoded) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDecodedMessageExtInMsgDecoded) Reset() { + var v DecodedMessageExtInMsgDecoded + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDecodedMessageExtInMsgDecoded) SetTo(v DecodedMessageExtInMsgDecoded) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDecodedMessageExtInMsgDecoded) Get() (v DecodedMessageExtInMsgDecoded, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptDecodedMessageExtInMsgDecoded) Or(d DecodedMessageExtInMsgDecoded) DecodedMessageExtInMsgDecoded { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptDecodedMessageExtInMsgDecodedWalletHighloadV2 returns new OptDecodedMessageExtInMsgDecodedWalletHighloadV2 with value set to v. +func NewOptDecodedMessageExtInMsgDecodedWalletHighloadV2(v DecodedMessageExtInMsgDecodedWalletHighloadV2) OptDecodedMessageExtInMsgDecodedWalletHighloadV2 { + return OptDecodedMessageExtInMsgDecodedWalletHighloadV2{ + Value: v, + Set: true, + } +} + +// OptDecodedMessageExtInMsgDecodedWalletHighloadV2 is optional DecodedMessageExtInMsgDecodedWalletHighloadV2. +type OptDecodedMessageExtInMsgDecodedWalletHighloadV2 struct { + Value DecodedMessageExtInMsgDecodedWalletHighloadV2 + Set bool +} + +// IsSet returns true if OptDecodedMessageExtInMsgDecodedWalletHighloadV2 was set. +func (o OptDecodedMessageExtInMsgDecodedWalletHighloadV2) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDecodedMessageExtInMsgDecodedWalletHighloadV2) Reset() { + var v DecodedMessageExtInMsgDecodedWalletHighloadV2 + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDecodedMessageExtInMsgDecodedWalletHighloadV2) SetTo(v DecodedMessageExtInMsgDecodedWalletHighloadV2) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDecodedMessageExtInMsgDecodedWalletHighloadV2) Get() (v DecodedMessageExtInMsgDecodedWalletHighloadV2, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptDecodedMessageExtInMsgDecodedWalletHighloadV2) Or(d DecodedMessageExtInMsgDecodedWalletHighloadV2) DecodedMessageExtInMsgDecodedWalletHighloadV2 { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptDecodedMessageExtInMsgDecodedWalletV3 returns new OptDecodedMessageExtInMsgDecodedWalletV3 with value set to v. +func NewOptDecodedMessageExtInMsgDecodedWalletV3(v DecodedMessageExtInMsgDecodedWalletV3) OptDecodedMessageExtInMsgDecodedWalletV3 { + return OptDecodedMessageExtInMsgDecodedWalletV3{ + Value: v, + Set: true, + } +} + +// OptDecodedMessageExtInMsgDecodedWalletV3 is optional DecodedMessageExtInMsgDecodedWalletV3. +type OptDecodedMessageExtInMsgDecodedWalletV3 struct { + Value DecodedMessageExtInMsgDecodedWalletV3 + Set bool +} + +// IsSet returns true if OptDecodedMessageExtInMsgDecodedWalletV3 was set. +func (o OptDecodedMessageExtInMsgDecodedWalletV3) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDecodedMessageExtInMsgDecodedWalletV3) Reset() { + var v DecodedMessageExtInMsgDecodedWalletV3 + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDecodedMessageExtInMsgDecodedWalletV3) SetTo(v DecodedMessageExtInMsgDecodedWalletV3) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDecodedMessageExtInMsgDecodedWalletV3) Get() (v DecodedMessageExtInMsgDecodedWalletV3, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptDecodedMessageExtInMsgDecodedWalletV3) Or(d DecodedMessageExtInMsgDecodedWalletV3) DecodedMessageExtInMsgDecodedWalletV3 { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptDecodedMessageExtInMsgDecodedWalletV4 returns new OptDecodedMessageExtInMsgDecodedWalletV4 with value set to v. +func NewOptDecodedMessageExtInMsgDecodedWalletV4(v DecodedMessageExtInMsgDecodedWalletV4) OptDecodedMessageExtInMsgDecodedWalletV4 { + return OptDecodedMessageExtInMsgDecodedWalletV4{ + Value: v, + Set: true, + } +} + +// OptDecodedMessageExtInMsgDecodedWalletV4 is optional DecodedMessageExtInMsgDecodedWalletV4. +type OptDecodedMessageExtInMsgDecodedWalletV4 struct { + Value DecodedMessageExtInMsgDecodedWalletV4 + Set bool +} + +// IsSet returns true if OptDecodedMessageExtInMsgDecodedWalletV4 was set. +func (o OptDecodedMessageExtInMsgDecodedWalletV4) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDecodedMessageExtInMsgDecodedWalletV4) Reset() { + var v DecodedMessageExtInMsgDecodedWalletV4 + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDecodedMessageExtInMsgDecodedWalletV4) SetTo(v DecodedMessageExtInMsgDecodedWalletV4) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDecodedMessageExtInMsgDecodedWalletV4) Get() (v DecodedMessageExtInMsgDecodedWalletV4, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptDecodedMessageExtInMsgDecodedWalletV4) Or(d DecodedMessageExtInMsgDecodedWalletV4) DecodedMessageExtInMsgDecodedWalletV4 { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptDepositStakeAction returns new OptDepositStakeAction with value set to v. func NewOptDepositStakeAction(v DepositStakeAction) OptDepositStakeAction { return OptDepositStakeAction{ diff --git a/oas_validators_gen.go b/oas_validators_gen.go index 8de057d..25b1acf 100644 --- a/oas_validators_gen.go +++ b/oas_validators_gen.go @@ -624,6 +624,150 @@ func (s *Auctions) Validate() error { return nil } +func (s *BlockCurrencyCollection) Validate() error { + var failures []validate.FieldError + if err := func() error { + if s.Other == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "other", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *BlockValueFlow) Validate() error { + var failures []validate.FieldError + if err := func() error { + if err := s.FromPrevBlk.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "from_prev_blk", + Error: err, + }) + } + if err := func() error { + if err := s.ToNextBlk.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "to_next_blk", + Error: err, + }) + } + if err := func() error { + if err := s.Imported.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "imported", + Error: err, + }) + } + if err := func() error { + if err := s.Exported.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "exported", + Error: err, + }) + } + if err := func() error { + if err := s.FeesCollected.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "fees_collected", + Error: err, + }) + } + if err := func() error { + if value, ok := s.Burned.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "burned", + Error: err, + }) + } + if err := func() error { + if err := s.FeesImported.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "fees_imported", + Error: err, + }) + } + if err := func() error { + if err := s.Recovered.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "recovered", + Error: err, + }) + } + if err := func() error { + if err := s.Created.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "created", + Error: err, + }) + } + if err := func() error { + if err := s.Minted.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "minted", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *BlockchainAccountInspect) Validate() error { var failures []validate.FieldError if err := func() error { @@ -672,6 +816,17 @@ func (s BlockchainAccountInspectCompiler) Validate() error { func (s *BlockchainBlock) Validate() error { var failures []validate.FieldError + if err := func() error { + if err := s.ValueFlow.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "value_flow", + Error: err, + }) + } if err := func() error { if s.PrevRefs == nil { return errors.New("nil is invalid value") @@ -708,6 +863,42 @@ func (s *BlockchainBlockShards) Validate() error { return nil } +func (s *BlockchainBlocks) Validate() error { + var failures []validate.FieldError + if err := func() error { + if s.Blocks == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Blocks { + if err := func() error { + if err := elem.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "blocks", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *BlockchainConfig) Validate() error { var failures []validate.FieldError if err := func() error { @@ -1369,6 +1560,151 @@ func (s *ContractDeployAction) Validate() error { return nil } +func (s *DecodedMessage) Validate() error { + var failures []validate.FieldError + if err := func() error { + if value, ok := s.ExtInMsgDecoded.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "ext_in_msg_decoded", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DecodedMessageExtInMsgDecoded) Validate() error { + var failures []validate.FieldError + if err := func() error { + if value, ok := s.WalletV3.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "wallet_v3", + Error: err, + }) + } + if err := func() error { + if value, ok := s.WalletV4.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "wallet_v4", + Error: err, + }) + } + if err := func() error { + if value, ok := s.WalletHighloadV2.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "wallet_highload_v2", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Validate() error { + var failures []validate.FieldError + if err := func() error { + if s.RawMessages == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "raw_messages", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DecodedMessageExtInMsgDecodedWalletV3) Validate() error { + var failures []validate.FieldError + if err := func() error { + if s.RawMessages == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "raw_messages", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DecodedMessageExtInMsgDecodedWalletV4) Validate() error { + var failures []validate.FieldError + if err := func() error { + if s.RawMessages == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "raw_messages", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *DepositStakeAction) Validate() error { var failures []validate.FieldError if err := func() error { @@ -2377,6 +2713,25 @@ func (s *JettonsBalances) Validate() error { return nil } +func (s *Message) Validate() error { + var failures []validate.FieldError + if err := func() error { + if err := s.MsgType.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "msg_type", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *MessageConsequences) Validate() error { var failures []validate.FieldError if err := func() error { @@ -2418,6 +2773,19 @@ func (s *MessageConsequences) Validate() error { return nil } +func (s MessageMsgType) Validate() error { + switch s { + case "int_msg": + return nil + case "ext_in_msg": + return nil + case "ext_out_msg": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + func (s *MethodExecutionResult) Validate() error { var failures []validate.FieldError if err := func() error { @@ -3119,10 +3487,45 @@ func (s *Transaction) Validate() error { Error: err, }) } + if err := func() error { + if value, ok := s.InMsg.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "in_msg", + Error: err, + }) + } if err := func() error { if s.OutMsgs == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range s.OutMsgs { + if err := func() error { + if err := elem.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{